Map.h

#pragma once
#include <ToolchefsSTL/Allocators/Allocator.h>
#include <ToolchefsSTL/Containers/Array.h>
 
 
namespace ToolchefsSTL
{
    template<typename T, typename K>
    class Map
    {
    public:
        
        typedef std::pair<T, K> Entry;
 
        template <class Iter>
        struct ReverseIterator
        {
            ReverseIterator(Iter* ptr) : m_ptr(ptr) {}
            ~ReverseIterator() = default;
            Iter* operator +(size_t value) const { return m_ptr - value; }
            Iter* operator -(size_t value) const { return m_ptr + value; }
            Iter* operator ++() { return --m_ptr; }
            Iter* operator --() { return ++m_ptr; }
            bool operator ==(const ReverseIterator& rhs) const { return m_ptr == rhs.m_ptr; }
            bool operator !=(const ReverseIterator& rhs) const { return m_ptr != rhs.m_ptr; }
            Iter operator *() const { return *m_ptr; }
            Iter* operator->() const { return m_ptr; }
            Iter* m_ptr;
        };
 
        typedef Entry value_type;
        typedef Entry& reference_type;
        typedef Entry* ptr_type;
 
        typedef Entry* iterator;
        typedef const Entry* const_iterator;
        typedef ReverseIterator<Entry> reverse_iterator;
        typedef ReverseIterator<const Entry> const_reverse_iterator;
 
        explicit Map(Allocator* allocator = defaultAllocator()) noexcept;
 
        ~Map() noexcept;
 
        Map(const Map& rhs) noexcept;
 
        Map& operator=(const Map& rhs) noexcept;
 
        Map(Map&& rhs) noexcept;
 
        Map& operator=(Map&& rhs) noexcept;
 
        bool operator==(const Map& rhs) const noexcept;
 
        void clear() noexcept;
 
        size_t size() const noexcept;
 
        size_t length() const noexcept;
 
        size_t capacity() const noexcept;
 
        void reserve(size_t new_capacity) noexcept;
 
        iterator find(const T& key) noexcept;
 
        const_iterator find(const T& key) const noexcept;
 
        constexpr K& operator[](const T& key) noexcept;
 
        constexpr K& operator[](T&& key) noexcept;
 
        iterator emplace(T&& key, K&& value) noexcept;
 
        iterator emplace(const T& key, const K& value) noexcept;
 
        iterator begin() noexcept;
 
        iterator end() noexcept;
 
        const_iterator cbegin() const noexcept;
 
        const_iterator cend() const noexcept;
 
        reverse_iterator rbegin() noexcept;
 
        reverse_iterator rend() noexcept;
 
        const_reverse_iterator crbegin() const noexcept;
 
        const_reverse_iterator crend() const noexcept;
 
        iterator erase(iterator it) noexcept;
 
        void erase(const T& key) noexcept;
 
    private:
 
        Array<Entry> m_data;
 
    };
}
 
#include "Map.impl.h"