Map.h

#pragma once
 
#include <map>
#include <unordered_map>
 
namespace mvlt 
{
    template <class MultiContainerIterator, class ContainerIterator, class KeyType, class ValueType>
    class AllMapIterator
    {
    private:
        // Is this iterator for multi container
        bool IsMultiMap;
 
        // Multi container iterator
        MultiContainerIterator DataMultiMapIt;
 
        // Container iterator
        ContainerIterator DataMapIt;
    public:
 
        AllMapIterator() {}
 
        AllMapIterator(MultiContainerIterator dataMultiMapIt,
            ContainerIterator dataMapIt, bool isMultiMap)
        {
            IsMultiMap = isMultiMap;
            DataMultiMapIt = dataMultiMapIt;
            DataMapIt = dataMapIt;
        };
 
        AllMapIterator(const AllMapIterator &other)
        {
            IsMultiMap = other.IsMultiMap;
            DataMultiMapIt = other.DataMultiMapIt;
            DataMapIt = other.DataMapIt;
        }
 
        AllMapIterator& operator=(const AllMapIterator& other)
        {
            if (&other != this)
            {
                IsMultiMap = other.IsMultiMap;
                DataMultiMapIt = other.DataMultiMapIt;
                DataMapIt = other.DataMapIt;
            }
 
            return *this;
        }
 
        bool operator!=(AllMapIterator const& other) const
        { 
            if (IsMultiMap)
                return DataMultiMapIt != other.DataMultiMapIt;
            else
                return DataMapIt != other.DataMapIt;
        }
 
        bool operator==(AllMapIterator const& other) const
        {
            if (IsMultiMap)
                return DataMultiMapIt == other.DataMultiMapIt;
            else
                return DataMapIt == other.DataMapIt;
        }
 
        AllMapIterator& operator++()
        {
            if (IsMultiMap)
                ++DataMultiMapIt;
            else
                ++DataMapIt;
            return *this;
        }
 
        AllMapIterator& operator--()
        {
            if (IsMultiMap)
                --DataMultiMapIt;
            else
                --DataMapIt;
            return *this;
        }
 
        std::pair<KeyType, ValueType> operator*() const
        {
            if (IsMultiMap)
                return *DataMultiMapIt;
            else
                return *DataMapIt;
        }
 
        ContainerIterator GetContainerIterator() const
        {
            return DataMapIt;
        }
 
        MultiContainerIterator GetMultiContainerIterator() const
        {
            return DataMultiMapIt;
        }
    };
 
    template <class  KeyType, class ValueType>
    using UnorderedMapIterator = AllMapIterator<typename std::unordered_multimap<KeyType, ValueType>::iterator, 
        typename std::unordered_map<KeyType, ValueType>::iterator, KeyType, ValueType>;
 
    template <class  KeyType, class ValueType>
    using MapIterator = AllMapIterator<typename std::multimap<KeyType, ValueType>::iterator, 
        typename std::map<KeyType, ValueType>::iterator, KeyType, ValueType>;
 
    template <class  KeyType, class ValueType>
    using ReverseMapIterator = AllMapIterator<typename std::multimap<KeyType, ValueType>::reverse_iterator, 
        typename std::map<KeyType, ValueType>::reverse_iterator, KeyType, ValueType>;
 
 
    template <class MultiContainer, class Container, class Iterator, class KeyType, class ValueType>
    class ParentMap
    {
    protected:
        bool IsMultiMap = false;
 
        // Multi container
        MultiContainer DataMultiMap;
 
        // Container
        Container DataMap;
    public:
 
        Iterator begin()
        {
            return Iterator(DataMultiMap.begin(), DataMap.begin(), IsMultiMap);
        }
 
        Iterator end()
        {
            return Iterator(DataMultiMap.end(), DataMap.end(), IsMultiMap);
        }
 
        Iterator Begin()
        {
            return Iterator(DataMultiMap.begin(), DataMap.begin(), IsMultiMap);
        }
 
        Iterator End()
        {
            return Iterator(DataMultiMap.end(), DataMap.end(), IsMultiMap);
        }
 
        template <class EmplaceKeyType, class EmplaceValueType>
        std::pair<Iterator, bool> Emplace(EmplaceKeyType&& key, EmplaceValueType&& value)
        {
            if (IsMultiMap)
            {
                auto dataMultiMapIt = DataMultiMap.emplace(std::forward<EmplaceKeyType>(key), std::forward<EmplaceValueType>(value));
                return std::pair<Iterator, bool>(Iterator(dataMultiMapIt, DataMap.end(), true), true);
            }
            else
            {
                auto dataMapIt = DataMap.emplace(std::forward<EmplaceKeyType>(key), std::forward<EmplaceValueType>(value));
                return std::pair<Iterator, bool>(Iterator(DataMultiMap.end(), dataMapIt.first, false), dataMapIt.second);
            }
        }
 
        std::pair<Iterator, Iterator> EqualRange(const KeyType& data)
        {
            if (IsMultiMap)
            {
                auto rangePair = DataMultiMap.equal_range(data);
                return std::pair<Iterator, Iterator>(Iterator(rangePair.first, DataMap.end(), true), Iterator(rangePair.second, DataMap.end(), true));
            }
            else 
            {
                auto rangePair = DataMap.equal_range(data);
                return std::pair<Iterator, Iterator>(Iterator(DataMultiMap.end(), rangePair.first, false), Iterator(DataMultiMap.end(), rangePair.second, false));
            }
        }
 
        Iterator Find(const KeyType& data)
        {
            if (IsMultiMap)
            {
                auto retIt = DataMultiMap.find(data);
                return Iterator(retIt, DataMap.end(), true);
            }
            else
            {
                auto retIt = DataMap.find(data);
                return Iterator(DataMultiMap.end(), retIt, false);
            }
        }
 
        std::size_t Erase(const KeyType& data)
        {
            std::size_t res;
            if (IsMultiMap)
                res = DataMultiMap.erase(data);
            else
                res = DataMap.erase(data);
            
            return res;
        }
 
        Iterator Erase(const Iterator& dataIt)
        {
            if (IsMultiMap)
            {
                auto retIt = DataMultiMap.erase(dataIt.GetMultiContainerIterator());
                return Iterator(retIt, DataMap.end(), true);
            }
            else
            {
                auto retIt = DataMap.erase(dataIt.GetContainerIterator());
                return Iterator(DataMultiMap.end(), retIt, false);
            }
        }
 
        void Clear()
        {
            if (IsMultiMap)
                DataMultiMap.clear();
            else
                DataMap.clear();
        }
 
        std::size_t Size()
        {
            if (IsMultiMap)
                return DataMultiMap.size();
            else
                return DataMap.size();
        }
    };
 
    template <class KeyType, class ValueType>
    class Map : public ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, 
        MapIterator<KeyType, ValueType>, KeyType, ValueType>
    {
    public:
        Map(bool isMultiMap)
        {
            ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::IsMultiMap = isMultiMap;
        }
 
        MapIterator<KeyType, ValueType> LowerBound(const KeyType& data)
        {
            return MapIterator<KeyType, ValueType>(ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::DataMultiMap.lower_bound(data), 
                ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::DataMap.lower_bound(data),
                ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::IsMultiMap);
        }
 
        MapIterator<KeyType, ValueType> UpperBound(const KeyType& data)
        {
            return MapIterator<KeyType, ValueType>(ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::DataMultiMap.upper_bound(data), 
                ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::DataMap.upper_bound(data),
                ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::IsMultiMap);
        }
 
        ReverseMapIterator<KeyType, ValueType> Rbegin()
        {
            return ReverseMapIterator<KeyType, ValueType>(ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::DataMultiMap.rbegin(), 
                ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::DataMap.rbegin(),
                ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::IsMultiMap);
        }
 
        ReverseMapIterator<KeyType, ValueType> Rend()
        {
            return ReverseMapIterator<KeyType, ValueType>(ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::DataMultiMap.rend(), 
            ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::DataMap.rend(), 
            ParentMap<std::multimap<KeyType, ValueType>, std::map<KeyType, ValueType>, MapIterator<KeyType, ValueType>, KeyType, ValueType>::IsMultiMap);
        }
    };
 
    template <class KeyType, class ValueType>
    class UnorderedMap : public ParentMap<std::unordered_multimap<KeyType, ValueType>, std::unordered_map<KeyType, ValueType>, 
        UnorderedMapIterator<KeyType, ValueType>, KeyType, ValueType>
    {
    public:
        UnorderedMap(bool isMultiMap)
        {
            ParentMap<std::unordered_multimap<KeyType, ValueType>, std::unordered_map<KeyType, ValueType>, UnorderedMapIterator<KeyType, ValueType>, KeyType, ValueType>::IsMultiMap = isMultiMap;
        }
    };
}