DataContainer.h

#pragma once
 
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
 
#include "DataSaver.h"
 
namespace mvlt
{
    template <class C>
    class DataContainer
    {
    protected:
        C Container;
 
    public:
        typedef typename C::iterator iterator;
 
        typedef typename C::const_iterator const_iterator;
 
        inline iterator begin() noexcept { return Container.begin(); }
        inline const_iterator cbegin() const noexcept { return Container.cbegin(); }
 
        inline iterator end() noexcept { return Container.end(); }
        inline const_iterator cend() const noexcept { return Container.cend(); }
 
        template <class T>
        void AddData(const std::string& key, const T& data) noexcept
        {
            Container.emplace(key, DataSaver(data));
        }
 
        template <class T, class F>
        void AddData(const std::string& key, const T& data, F&& deleteFunc) noexcept
        {
            Container.emplace(key, DataSaver(data, deleteFunc));
        }
 
        void AddDataFromDataSaver(const std::string& key, const DataSaver& dataSaver) noexcept
        {
            Container.emplace(key, dataSaver);
        }
 
        template <class T>
        void SetData(const std::string& key, const T& data) noexcept
        {
            SetData(key, data, nullptr);
        }
 
        template <class T, class F>
        void SetData(const std::string& key, const T& data, F&& deleteFunc) noexcept
        {
            // Find data iterator
            auto findResIt = Container.find(key);
 
            // Checking whether there was such a key in the container
            if (findResIt == Container.end())
                AddData(key, data, deleteFunc); // Adding data to the container if there was no key
            else
                findResIt->second.SetData(data, deleteFunc); // Setting new data for the key if it was already in the container
        }
 
        void SetDataFromDataSaver(const std::string& key, const DataSaver& dataSaver) noexcept
        {
            // Find data iterator
            auto findResIt = Container.find(key);
 
            // Checking whether there was such a key in the container
            if (findResIt == Container.end())
                AddDataFromDataSaver(key, dataSaver); // Adding data to the container if there was no key
            else
                findResIt->second = dataSaver; // Setting new data for the key if it was already in the container
        }
 
        bool SetDataFromString(const std::string& key, const std::string& str) noexcept
        {
            // Find data iterator
            auto findResIt = Container.find(key);
 
            // Checking whether there was such a key in the container
            if (findResIt != Container.end())
                return findResIt->second.SetDataFromString(str);
 
            return false;
        }
 
        template <class T>
        bool GetData(const std::string& key, T& data) const noexcept
        {
            auto findResIt = Container.find(key);
            if (findResIt == Container.end())
                return false;
 
            findResIt->second.GetData(data);
            return true;
        }
 
        bool GetDataSaver(const std::string& key, DataSaver& dataSaver) const noexcept
        {
            auto findResIt = Container.find(key);
            if (findResIt == Container.end())
                return false;
 
            dataSaver = findResIt->second;
            return true;
        }
        
        bool GetDataAsString(const std::string& key, std::string& str) const noexcept
        {
            auto findResIt = Container.find(key);
            if (findResIt == Container.end())
                return false;
 
            str = findResIt->second.Str();
            return true;
        }
 
        bool IsData(const std::string& key) const noexcept
        {
            return Container.find(key) != Container.end();
        }
 
        void EraseData(const std::string& key) noexcept
        {
            auto findResIt = Container.find(key);
            if (findResIt != Container.end())
            {
                findResIt->second.ResetData();
                Container.erase(findResIt);
            }
        }
 
        void Clear() noexcept
        {
            Container.clear();
        }
 
        std::size_t Size() const noexcept
        {
            return Container.size();
        }
    };
 
    class DataHashMap : public DataContainer<std::unordered_map<std::string, DataSaver>> {};
 
    class DataMultiHashMap : public DataContainer<std::unordered_multimap<std::string, DataSaver>>
    {
    public:
        std::pair<DataContainer::const_iterator, DataContainer::const_iterator> GetAllData(const std::string& key) const noexcept
        {
            return Container.equal_range(key);
        }
    };
 
    class DataMap : public DataContainer<std::map<std::string, DataSaver>> {};
 
    class DataMultiMap : public DataContainer<std::multimap<std::string, DataSaver>>
    {
    public:
        std::pair<DataContainer::const_iterator, DataContainer::const_iterator> GetAllData(const std::string& key) const noexcept
        {
            return Container.equal_range(key);
        }
    };
}