map.h

Go to the documentation of this file.

 
#ifndef MAXOS_COMMON_MAP_H
#define MAXOS_COMMON_MAP_H
 
#include <common/vector.h>
#include <common/pair.h>
 
 
namespace MaxOS::common {
 
    template<class Key, class Value> class MapIterationHandler {
        public:
            MapIterationHandler();
            ~MapIterationHandler() = default;
 
            virtual void on_read(Key, Value);
            virtual void on_end_of_stream();
    };
 
    template<class Key, class Value> class Map {
        protected:
            Vector<Pair<Key, Value>> m_elements;                             
 
        public:
            typedef typename Vector<Pair<Key, Value>>::iterator iterator;   
 
            Map();
            ~Map();
 
            Value& operator [](Key);
 
            bool empty();
            int size();
 
            iterator begin();
            iterator end();
            iterator find(Key);
 
            iterator push_back(Key, Value);
            Pair<Key, Value> pop_back();
 
            iterator push_front(Key, Value);
            Pair<Key, Value> pop_front();
 
            void insert(Key, Value);
 
            void erase(Key);
            void erase(iterator position);
            void clear();
 
            void reserve(size_t amount);
            void increase_size();
 
            void iterate(MapIterationHandler<Key, Value>* handler);
            void iterate(void (* callback)(Key&, Value&));
 
    };
 
    template<class Key, class Value> MapIterationHandler<Key, Value>::MapIterationHandler() = default;
 
 
 
    template<class Key, class Value> void MapIterationHandler<Key, Value>::on_end_of_stream() {
 
    }
 
    template<class Key, class Value> void MapIterationHandler<Key, Value>::on_read(Key, Value) {
 
    }
 
    template<class Key, class Value> Map<Key, Value>::Map() = default;
 
    template<class Key, class Value> Map<Key, Value>::~Map() = default;
 
    template<class Key, class Value> Value& Map<Key, Value>::operator [](Key key) {
 
        // Return the value of the key (second item in the pair)
        return find(key)->second;
    }
 
    template<class Key, class Value> typename Map<Key, Value>::iterator Map<Key, Value>::begin() {
        return m_elements.begin();
    }
 
    template<class Key, class Value> typename Map<Key, Value>::iterator Map<Key, Value>::end() {
        return m_elements.end();
    }
 
    template<class Key, class Value> typename Map<Key, Value>::iterator Map<Key, Value>::find(Key element) {
 
        // Search for the element
        for(iterator it = begin(); it != end(); it++)
            if(it->first == element)
                return it;
 
        // Item not found
        return end();
 
    }
 
    template<class Key, class Value> Map<Key, Value>::iterator Map<Key, Value>::push_back(Key key, Value value) {
        return m_elements.push_back(Pair<Key, Value>(key, value));
    }
 
    template<class Key, class Value> Pair<Key, Value> Map<Key, Value>::pop_back() {
        return m_elements.pop_back();
    }
 
    template<class Key, class Value> Map<Key, Value>::iterator Map<Key, Value>::push_front(Key key, Value value) {
        return m_elements.push_front({ key, value });
    }
 
    template<class Key, class Value> Pair<Key, Value> Map<Key, Value>::pop_front() {
        return m_elements.pop_front();
    }
 
    template<class Key, class Value> bool Map<Key, Value>::empty() {
        return m_elements.empty();
    }
 
    template<class Key, class Value> int Map<Key, Value>::size() {
        // Return the size of the vector
        return m_elements.size();
 
    }
 
    template<class Key, class Value> void Map<Key, Value>::clear() {
        m_elements.clear();
    }
 
    template<class Key, class Value> void Map<Key, Value>::insert(Key key, Value value) {
 
        // Find the element
        iterator it = find(key);
 
        // If the element is found then update the value
        if(it != end()) {
            it->second = value;
        } else {
            // Otherwise, add a new element
            m_elements.push_back(Pair<Key, Value>(key, value));
        }
    }
 
    template<class Key, class Value> void Map<Key, Value>::erase(Key key) {
 
        // Find the element
        iterator it = find(key);
 
        // If the element is found then remove it
        if(it != end()) {
            m_elements.erase(it);
        }
 
    }
 
    template<class Key, class Value> void Map<Key, Value>::erase(Map::iterator position) {
        m_elements.erase(position);
 
    }
 
    template<class Key, class Value> void Map<Key, Value>::reserve(size_t amount) {
        m_elements.reserve(amount);
    }
 
    template<class Key, class Value> void Map<Key, Value>::increase_size() {
        m_elements.increase_size();
    }
 
    template<class Key, class Value> void Map<Key, Value>::iterate(MapIterationHandler<Key, Value>* handler) {
 
        // Loop through the elements
        for(auto& it : m_elements) {
 
            // Call the handler
            handler->on_read(it.first, it.second);
        }
 
        // Call the handler
        handler->on_end_of_stream();
 
    }
 
    template<class Key, class Value> void Map<Key, Value>::iterate(void (* callback)(Key&, Value&)) {
 
        // Call the callback for each element
        for(auto& it : m_elements) {
            callback(it.first, it.second);
        }
    }
}
 
 
#endif //MAXOS_COMMON_MAP_H