Hash.hpp

Go to the documentation of this file.

#include <etk/types.hpp>

#pragma once

namespace etk {
    template<class MY_TYPE> class HashData {
        public:
            std::string m_key; 
            MY_TYPE m_value; 

            HashData(const std::string& _key, const MY_TYPE& _val) :
              m_key(_key),
              m_value(_val) {
                // nothing to do ...
            }
    };
    template<class MY_TYPE> class Hash {
        private:
            std::vector<HashData<MY_TYPE>* > m_data; 
        public:
            Hash(int32_t _count = 0) :
              m_data(_count) {
                // nothing to do
            }
            ~Hash() {
                clear();
            }
            void clear() {
                for (auto &it : m_data) {
                    if (it != nullptr) {
                        delete(it);
                        it=nullptr;
                    }
                }
                m_data.clear();
            }
            int64_t getId(const std::string& _key) const {
                for (size_t iii=0; iii<m_data.size(); iii++) {
                    if (m_data[iii] != nullptr) {
                        //TK_INFO("Compare key : '" << m_data[iii]->m_key << "' with '" << _key << "'" );
                        if (m_data[iii]->m_key == _key) {
                            return iii;
                        }
                    }
                }
                //TK_ERROR(" ==> not fund key '" << _key << "'" );
                return -1;
            }
            bool exist(const std::string& _name) const {
                int64_t elementId = getId(_name);
                //TK_INFO(" Exist ? '" << _name << "' id=" << elementId );
                if (elementId<0) {
                    //TK_INFO("     ==> return false" );
                    return false;
                }
                //TK_INFO("     ==> return true" );
                return true;
            }
            MY_TYPE& get(const std::string& _key) const {
                static MY_TYPE g_error;
                int64_t elementId = getId(_key);
                if (elementId<0) {
                    //TK_ERROR("try to acces at an unexistant hash element : " << _key);
                    return g_error;
                }
                return m_data[elementId]->m_value;
            }
            MY_TYPE& operator[] (const std::string& _key) {
                return get(_key);
            }
            const MY_TYPE& operator[] (const std::string& _key) const {
                return get(_key);
            }
            void add(const std::string& _key, const MY_TYPE& _value) {
                int64_t elementId = getId(_key);
                if (elementId <0) {
                    HashData<MY_TYPE>* tmp = new HashData<MY_TYPE>(_key, _value);
                    if (tmp == nullptr) {
                        //TK_ERROR("allocation error in Hash table : '" << _key << "'");
                        return;
                    }
                    m_data.push_back(tmp);
                    return;
                }
                m_data[elementId]->m_value = _value;
            }
            void set(const std::string& _key, const MY_TYPE& _value) {
                add(_key, _value);
            }
            void remove(const std::string& _key) {
                int64_t elementId = getId(_key);
                if (elementId <0) {
                    //nothing to do ==> not existed
                    return;
                }
                delete(m_data[elementId]);
                m_data[elementId] = nullptr;
                m_data.erase(m_data.begin()+elementId);
            }
            int32_t size() const {
                return m_data.size();
            }
            MY_TYPE& operator[] (size_t _pos) {
                return getValue(_pos);
            }
            const MY_TYPE& operator[] (size_t _pos) const {
                return getValue(_pos);
            }
            const std::string& getKey(size_t _pos) const {
                // NOTE :Do not change log level, this generate error only in debug mode
                #if DEBUG_LEVEL > 2
                    if(_pos>m_data.size()){
                        //TK_CRITICAL("Access to an unexistant data in hach : " << _pos << "/ " << m_data.size());
                    }
                #endif
                return m_data[_pos]->m_key;
            }
            std::vector<std::string> getKeys() const {
                std::vector<std::string> keys;
                for (auto &it : m_data) {
                    if (it != nullptr) {
                        keys.push_back(it->m_key);
                    }
                }
                return keys;
            }
            const MY_TYPE& getValue(size_t _pos) const {
                // NOTE :Do not change log level, this generate error only in debug mode
                #if DEBUG_LEVEL > 2
                    if(_pos>m_data.size()){
                        //TK_CRITICAL("Access to an unexistant data in hach : " << _pos << "/ " << m_data.size());
                    }
                #endif
                return m_data[_pos]->m_value;
            }
            MY_TYPE& getValue(size_t _pos) {
                // NOTE :Do not change log level, this generate error only in debug mode
                #if DEBUG_LEVEL > 2
                    if(_pos>m_data.size()){
                        //TK_CRITICAL("Access to an unexistant data in hach : " << _pos << "/ " << m_data.size());
                    }
                #endif
                return m_data[_pos]->m_value;
            }
    };
}