Map.impl.h

#pragma once
 
namespace ToolchefsSTL
{
    template<typename T, typename K>
    Map<T,K>::Map(Allocator* allocator) noexcept:
        m_data(allocator)
    {
        
    }
 
    template<typename T, typename K>
    Map<T, K>::~Map() noexcept
    {
        clear();
    }
 
    template<typename T, typename K>
    Map<T, K>::Map(const Map& rhs) noexcept :
        m_data(rhs.m_data)
    {
        
    }
 
    template<typename T, typename K>
    Map<T, K>& Map<T, K>::operator=(const Map& rhs) noexcept
    {
        m_data = rhs.m_data;
        return *this;
    }
 
    template<typename T, typename K>
    Map<T, K>::Map(Map&& rhs) noexcept :
        m_data(std::move(rhs.m_data))
    {
    }
 
    template<typename T, typename K>
    Map<T, K>& Map<T, K>::operator=(Map&& rhs) noexcept
    {
        m_data = std::move(rhs.m_data);
        return *this;
    }
 
    template<typename T, typename K>
    bool Map<T, K>::operator==(const Map& rhs) const noexcept
    {
        if (rhs.m_data.length() != m_data.length()) return false;
        for (size_t i = 0; i < m_data.length(); ++i)
        {
            auto& item = m_data[i];
            auto& rhs_item = rhs.m_data[i];
            if (item.first != rhs_item.first || item.second != rhs_item.second) return false;
        }
        return true;
    }
 
    template<typename T, typename K>
    void Map<T, K>::clear() noexcept
    {
        m_data.clear();
    }
 
    template<typename T, typename K>
    size_t Map<T, K>::size() const noexcept
    {
        return m_data.length();
    }
 
    template<typename T, typename K>
    size_t Map<T, K>::length() const noexcept
    {
        return m_data.length();
    }
 
    template<typename T, typename K>
    size_t Map<T, K>::capacity() const noexcept
    {
        return m_data.capacity();
    }
 
    template<typename T, typename K>
    void Map<T, K>::reserve(size_t new_capacity) noexcept
    {
        return m_data.reserve(new_capacity);
    }
 
    template<typename T, typename K>
    typename Map<T, K >::iterator Map<T, K>::find(const T& key) noexcept
    {
        auto end_it = end();
        for (auto it = begin(); it != end_it; ++it)
        {
            if (it->first == key) return it;
        }
        return end_it;
    }
 
    template<typename T, typename K>
    typename Map<T, K >::const_iterator Map<T, K>::find(const T& key) const noexcept
    {
        auto end_it = cend();
        for (auto it = cbegin(); it != end_it; ++it)
        {
            if (it->first == key) return it;
        }
        return end_it;
    }
 
    template<typename T, typename K>
    constexpr K& Map<T, K>::operator[](const T& key) noexcept
    {
        auto it = find(key);
        if (it != end())
            return it->second;
 
        m_data.emplace_back(key, K());
        return m_data.back().second;
    }
 
    template<typename T, typename K>
    constexpr K& Map<T, K>::operator[](T&& key) noexcept
    {
        auto it = find(key);
        if (it != end())
            return it->second;
 
        m_data.emplace_back(key, K());
        return m_data.back().second;
    }
 
    template<typename T, typename K>
    typename Map<T, K>::iterator Map<T, K>::emplace(T&& key, K&& value) noexcept
    {
        auto it = find(key);
        if (it != end())
            return it;
        m_data.emplace_back(key, value);
        return m_data.begin() + (m_data.length() - 1);
    }
 
    template<typename T, typename K>
    typename Map<T, K>::iterator Map<T, K>::emplace(const T& key, const K& value) noexcept
    {
        auto it = find(key);
        if (it != end())
            return it;
        m_data.emplace_back(key, value);
        return m_data.begin() + (m_data.length() - 1);
    }
 
    template<typename T, typename K>
    typename Map<T, K>::iterator Map<T, K>::begin() noexcept
    {
        return m_data.begin();
    }
 
    template<typename T, typename K>
    typename Map<T, K>::iterator Map<T, K>::end() noexcept
    {
        return m_data.end();
    }
 
    template<typename T, typename K>
    typename Map<T, K>::const_iterator Map<T, K>::cbegin() const noexcept
    {
        return m_data.cbegin();
    }
 
    template<typename T, typename K>
    typename Map<T, K>::const_iterator Map<T, K>::cend() const noexcept
    {
        return m_data.cend();
    }
 
    template<typename T, typename K>
    typename Map<T, K>::reverse_iterator Map<T, K>::rbegin() noexcept
    {
        return reverse_iterator(&m_data.back());
    }
 
    template<typename T, typename K>
    typename Map<T, K>::reverse_iterator Map<T, K>::rend() noexcept
    {
        Entry* front_ptr = &m_data.front();
        return reverse_iterator(--front_ptr);
    }
 
    template<typename T, typename K>
    typename Map<T, K>::const_reverse_iterator Map<T, K>::crbegin() const noexcept
    {
        return const_reverse_iterator(&m_data.back());
    }
 
    template<typename T, typename K>
    typename Map<T, K>::const_reverse_iterator Map<T, K>::crend() const noexcept
    {
        Entry* front_ptr = const_cast<Entry*>(&m_data.front());
        return const_reverse_iterator(--front_ptr);
    }
 
    template<typename T, typename K>
    typename Map<T, K>::iterator Map<T, K>::erase(iterator it) noexcept
    {
        if (it == end()) return it;
        auto index = it - begin();
        m_data.erase(index);
        return begin() + index;
    }
 
    template<typename T, typename K>
    void Map<T, K>::erase(const T& key) noexcept
    {
        auto it = find(key);
        if (it != end())
            erase(it);
    }
 
 
}