mn_basic_light_map.hpp

Go to the documentation of this file.

/*
*This file is part of the Mini Thread Library (https://github.com/RoseLeBlood/MiniThread ).
*Copyright (c) 2018 Amber-Sophia Schroeck
*
*The Mini Thread Library is free software; you can redistribute it and/or modify
*it under the terms of the GNU Lesser General Public License as published by
*the Free Software Foundation, version 3, or (at your option) any later version.
 
*The Mini Thread Library is distributed in the hope that it will be useful, but
*WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
*General Public License for more details.
*
*You should have received a copy of the GNU Lesser General Public
*License along with the Mini Thread  Library; if not, see
*<https://www.gnu.org/licenses/>.
*/
#ifndef __MINILIB_BASIC_LIGHT_MAP_H__
#define __MINILIB_BASIC_LIGHT_MAP_H__
 
#include "../mn_config.hpp"
 
#include "../mn_algorithm.hpp"
#include "../mn_iterator.hpp"
#include "../mn_typetraits.hpp"
 
#include "mn_pair.hpp"
#include "mn_vector.hpp"
 
 
namespace mn {
    namespace container {
 
        template <class TKey, class TValue,
                  class TALLOCATOR = memory::default_allocator,
                  class TPairType = mn::container::pair<TKey, TValue>,
                  class TContainer = mn::container::vector<TPairType, TALLOCATOR> >
        class basic_light_map {
        public:
            using mapped_type = TValue;
            using key_type = TKey;
 
            using value_type = TPairType;
            using reference = TPairType&;
            using pointer = TPairType*;
            using const_reference = const TPairType&;
            using const_pointer = const TPairType*;
 
            using difference_type = mn::ptrdiff_t;
            using size_type = mn::size_t;
 
            using iterator = TValue*;
            using const_iterator = const TValue*;
 
            using self_type = basic_light_map < TKey, TValue, TALLOCATOR, TPairType, TContainer>;
 
            basic_light_map(const size_type start_size = 32) noexcept
                :  m_ayKeyValue(start_size) { }
 
            ~basic_light_map() {
                m_ayKeyValue.clear();
            }
 
 
            void clear() {
                m_ayKeyValue.clear();
            }
 
            template< class... Args >
            mn::container::pair<iterator, bool> assign(const key_type& key, Args && ... args) {
                value_type _value(key, mn::forward<Args>(args)...);
 
                return assign(_value);
            }
 
            mn::container::pair<iterator, bool> assign(const value_type& vValue) {
                mn::container::pair<iterator, bool> _ret(vValue.seconde, false);
 
                for(typename TContainer::iterator it = m_ayKeyValue.begin();
                            it != m_ayKeyValue.end(); it++) {
                    value_type _pair = *it;
 
                    if(_pair.first == vValue.first) {
                        m_ayKeyValue.erase(it);
                        m_ayKeyValue.insert(vValue);
                        _ret->second = true;
                    }
                }
                return _ret;
            }
 
            template< class... Args >
            mn::container::pair<iterator, bool> emplace(const key_type& key, Args && ... args) {
                value_type _value = value_type(key, mn::forward<Args>(args)...);
 
                return insert(_value);
            }
 
            mn::container::pair<iterator, bool> insert( const value_type& value ) {
                mn::container::pair<iterator, bool> result(&value, false);
 
                if(find(value.first) == nullptr) {
                    m_ayKeyValue.push_back(value);
                    result.second = find(value.first) != nullptr;
                }
 
                return result;
            }
 
            template< class... Args >
            void insert_or_assign(const key_type& key, Args && ... args) {
                value_type _value(key, mn::forward<Args>(args)...);
 
                auto iter = find(key);
                if(iter == nullptr)
                    insert(_value);
                else
                    assign(_value);
 
            }
 
            bool insert(const key_type& key, const mapped_type& value) {
                return insert(value_type(key, value)).second;
            }
 
            bool insert(key_type&& key, mapped_type&& value) {
                return insert(value_type( mn::forward(key), mn::forward(value)) ).second;
            }
 
 
 
 
            iterator erase( const_iterator pos ) {
                return m_ayKeyValue.erase(pos);
            }
 
            iterator erase( const_iterator first, const_iterator last ) {
                return m_ayKeyValue.erase(first, last);
            }
            size_type erase( const key_type& tKey ) {
                if(empty()) return 0;
 
                size_type _ret  = 0;
 
                for(typename TContainer::iterator it = m_ayKeyValue.begin();
                            it != m_ayKeyValue.end(); it++) {
                    value_type _pair = *it;
 
                    if(_pair.first == tKey) {
                        m_ayKeyValue.erase(it); _ret =  1;
                    }
                }
 
                return _ret;
            }
            iterator find(const key_type& tKey) noexcept {
                if(empty()) return nullptr;
 
                for(typename TContainer::iterator it = m_ayKeyValue.begin();
                            it != m_ayKeyValue.end(); it++) {
                    value_type _pair = *it;
 
                    if(_pair.first == tKey) {
                        return &(_pair.second);
                    }
                }
 
                return nullptr;
            }
            const_iterator find(const key_type& tKey) const noexcept {
                if(empty()) return nullptr;
 
                for(typename TContainer::iterator it = m_ayKeyValue.begin();
                            it != m_ayKeyValue.end(); it++) {
                    value_type _pair = *it;
 
                    if(_pair.first == tKey) {
                        return &(_pair.second);
                    }
                }
 
                return nullptr;
            }
 
            constexpr bool empty() const noexcept {
                return m_ayKeyValue.is_empty();
            }
 
            constexpr size_type size() const noexcept {
                return m_ayKeyValue.get_used();
            }
 
            size_type count( const key_type& key ) const {
                return (find(key) != nullptr) ? 1 : 0;
            }
 
 
            void swap( self_type& other ) {
                swap(m_ayKeyValue, other.m_ayKeyValue);
            }
 
            iterator operator[](const key_type& tKey) noexcept {
                return find(tKey);
            }
            const_iterator operator[](const key_type& tKey) const noexcept {
                return find(tKey);
            }
        private:
            TContainer m_ayKeyValue;
        };
 
        template <class TKey, class TValue>
        using map = basic_light_map< TKey, TValue >;
 
    }
}
 
#endif // __MINILIB_BASIC_LIGHT_MAP_H__