map.hpp

Go to the documentation of this file.

 
#ifndef __MYMAP_HPP__
#define __MYMAP_HPP__
// C++ libraries
#include "stdexcept"
#include "vector"
// Code
namespace lib {
template <class _K, class _D> class mapData {
  public:
    _K key;
    _D data;
 
  public:
    mapData() {}
    mapData(_K key, _D data) {
        this->key = key;
        this->data = data;
    }
    bool operator==(lib::mapData<_K, _D> val) {
        if ((this->key == val.key) && (this->data == val.data)) {
            return true;
        } else {
            return false;
        }
    }
};
template <class _K, class _D> class map {
  private:
    std::vector<mapData<_K, _D>> content;
 
  public:
    map() {
        this->content.clear();
    }
    map(map const&) = default;
    map(std::initializer_list<lib::mapData<_K, _D>> init_list) {
        this->content.reserve(init_list.size()); // Reserve space for efficiency
        for (const auto& element : init_list) {
            this->content.push_back(element);
        }
    }
    void push_back(lib::mapData<_K, _D> element) {
        this->content.push_back(element);
    }
    void push_back(_K key, _D data) {
        lib::mapData<_K, _D> element(key, data);
        this->content.push_back(element);
    }
    void push_back_check(lib::mapData<_K, _D> element) {
        if (this->get(element.key) != NULL)
            throw std::runtime_error("lib::map - Key already exist!");
        this->push_back(element);
    }
    void push_back_check(_K key, _D data) {
        if (this->get(key) != NULL)
            throw std::runtime_error("lib::map - Key already exist!");
        this->push_back(key, data);
    }
    lib::mapData<_K, _D> pop_back() {
        lib::mapData<_K, _D> ret = this->content.at(this->content.size() - 1);
        this->content.pop_back();
        return ret;
    }
    const _D* get(_K key) {
        if (this->content.empty())
            return NULL;
        for (unsigned int i = 0; i < this->content.size(); i++) {
            lib::mapData<_K, _D>* elem = &(this->content.at(i));
            if (elem->key == key) {
                return &(elem->data);
            }
        }
        return NULL;
    }
    lib::mapData<_K, _D>* get_ptr(_K key) {
        if (this->content.empty())
            return NULL;
        for (unsigned int i = 0; i < this->content.size(); i++) {
            lib::mapData<_K, _D>* elem = &(this->content.at(i));
            if (elem->key == key) {
                return elem;
            }
        }
        return NULL;
    }
    bool contains_key(_K key) {
        for (lib::mapData<_K, _D> data : this->content) {
            if (data.key == key)
                return true;
        }
        return false;
    }
    bool contains(_D value) {
        for (lib::mapData<_K, _D> data : this->content) {
            if (data.data == value)
                return true;
        }
        return false;
    }
    void clear() {
        this->content.clear();
    }
    lib::mapData<_K, _D> at(__SIZE_TYPE__ i) {
        return this->content.at(i);
    }
    lib::mapData<_K, _D>* ptr_at(__SIZE_TYPE__ i) {
        return &(this->content.at(i));
    }
    void remove(__SIZE_TYPE__ idx) {
        if (idx >= this->content.size())
            return;
        this->content.erase(std::next(this->content.begin(), idx));
    }
    void remove(_K key) {
        __SIZE_TYPE__ idx = this->content.size();
        for (unsigned int i = 0; i < this->content.size(); i++) {
            lib::mapData<_K, _D> elem = this->content.at(i);
            if (elem.key == key) {
                idx = i;
            }
        }
        if (idx >= this->content.size())
            return;
        this->content.erase(std::next(this->content.begin(), idx));
    }
    std::vector<_K> keys() {
        std::vector<_K> ret;
        for (auto elem : this->content) {
            ret.push_back(elem.key);
        }
        return ret;
    }
    __SIZE_TYPE__ size() {
        return this->content.size();
    }
    lib::mapData<_K, _D> operator[](__SIZE_TYPE__ i) {
        return this->content.at(i);
    }
    lib::map<_K, _D> operator+(lib::mapData<_K, _D> val) {
        lib::map<_K, _D> map;
        map.content = this->content;
        map.content.push_back(val);
        return map;
    }
    lib::map<_K, _D> operator+=(lib::mapData<_K, _D> val) {
        lib::map<_K, _D> map;
        map.content = this->content;
        map.content.push_back(val);
        this->content = map.content;
        return map;
    }
    lib::map<_K, _D> operator+(lib::map<_K, _D> val) {
        lib::map<_K, _D> map;
        map.content = this->content;
        for (lib::mapData<_K, _D> elem : val.content) {
            map.push(elem);
        }
        return map;
    }
    lib::map<_K, _D> operator+=(lib::map<_K, _D> val) {
        lib::map<_K, _D> map;
        map.content = this->content;
        for (lib::mapData<_K, _D> elem : val.content) {
            map.push(elem);
        }
        this->content = map.content;
        return map;
    }
    lib::map<_K, _D> operator=(lib::map<_K, _D> val) {
        this->content = val.content;
        return *this;
    }
    lib::map<_K, _D> operator=(lib::mapData<_K, _D> val) {
        this->content.clear();
        this->content.push_back(val);
        return *this;
    }
    bool operator==(lib::map<_K, _D> val) {
        if (this->content.size() != val.content.size())
            return false;
        for (__SIZE_TYPE__ i = 0; i < this->content.size(); i++) {
            if (this->content.at(i) != val.content.at(i))
                return false;
        }
        return true;
    }
    typename std::vector<mapData<_K, _D>>::iterator begin() {
        return this->content.begin();
    }
    typename std::vector<mapData<_K, _D>>::iterator end() {
        return this->content.end();
    }
    typename std::vector<mapData<_K, _D>>::const_iterator begin() const {
        return this->content.begin();
    }
    typename std::vector<mapData<_K, _D>>::const_iterator end() const {
        return this->content.end();
    }
    bool empty() {
        return this->content.empty();
    }
    void erase(_K key) {
        for (unsigned int i = 0; i < this->content.size(); i++) {
            if (this->content.at(i).key == key) {
                this->content.erase(this->content.begin() + i);
            }
        }
    }
};
} // namespace lib
#endif // __MYMAP_HPP__