Map.h

 
#ifndef ACTIVE_CONTAINER_MAP
#define ACTIVE_CONTAINER_MAP
 
#include "Active/Utility/Cloner.h"
#include "Active/Utility/Mover.h"
 
#include <map>
 
namespace active::container {
 
    template<class Key, class T> requires utility::Clonable<T>
    class Map : public std::map<Key, std::unique_ptr<T>> {
    public:
        
        // MARK: Types
        
        using base = std::map<Key, std::unique_ptr<T>>;
        using raw_type = std::pair<const Key, T>;
        using mapped_type = typename base::mapped_type;
        using value_type = typename base::value_type;
        using node_type = typename base::node_type;
        using size_type = typename base::size_type;
        using iterator = typename base::iterator;
        using const_iterator = typename base::const_iterator;
        
        // MARK: Constructors
        
        Map() : base() {}
        Map(const Map& source) : base() { cloneFrom(source); }
        Map(Map&& source) : base(std::move(source)) {}
        virtual ~Map() = default;
        
        // MARK: Operators
        
        auto operator= (const Map& source) {
            if (this != &source) {
                base::clear();
                cloneFrom(source);
            }
            return *this;
        }
        auto operator= (Map&& source) {
            if (this != &source)
                base::operator=(std::move(source));
            return *this;
        }
        mapped_type& operator[] (const Key& key) { return base::operator[](key); }
        
        // MARK: Functions (const)
        
        auto find(const Key& key) const { return base::find(key); }
        
        // MARK: Functions (mutating)
        
        auto insert(const raw_type& item) { return emplace(item.first, clone(item.second)); }
        auto insert(const value_type& item) { return emplace(item.first, clone(*item.second)); }
        auto insert(value_type&& item) {
            emplace(item.first, std::move(item.second));
        }
        auto insert(node_type&& node) { return base::insert(std::move(node)); }
        auto emplace(const Key& key, mapped_type&& item) { return base::emplace(key, std::move(item)); }
        auto emplace(const Key& key, T&& item) {
            if constexpr(utility::Movable<T>)
                base::emplace(key, cloneMove(std::move(item)));
            else
                base::emplace(key, clone(item));
        }
        auto release(iterator& pos) { return release(const_iterator(pos)); }
        auto release(const_iterator pos) {
            auto item = std::move(pos.second);
            erase(pos);
            return item;
        }
        
    private:
        void cloneFrom(const Map& source) {
            for (const auto& item : source)
                base::operator[](item.first) = (item.second ? clone(*item.second) : mapped_type());
        }
    };
    
}
 
#endif  //ACTIVE_CONTAINER_MAP