Hashmap.h

Go to the documentation of this file.

 
#pragma once
 
#pragma warning(error: 4239)
 
#include <map>
#include <stdexcept>
#include <algorithm>
#include <assert.h>
#include <tuple>
#include <sstream>
 
#include "../Utils/Assert.h"
 
#include "Iterator.h"
#include <Gorgon/TMP.h>
 
namespace Gorgon { 
    namespace Containers {
 
        template<class K_, class T_, K_ (*KeyFn)(const T_&) = (K_(*)(const T_&))nullptr, template <class ...> class M_=std::map, class C_=std::less<K_>>
        class Hashmap {
            using MapType=M_<K_, T_*, C_, std::allocator<std::pair<const K_, T_*>>>;
            
            template <class I_, class H_>
            class Iterator_ : 
            public Containers::ValueIterator<
                Iterator_<I_, H_>, 
                std::pair<const typename H_::KeyType, typename H_::ValueType &>
            > {
                typedef std::pair<const typename H_::KeyType, typename H_::ValueType &> Type;
                friend class Containers::ValueIterator<Iterator_, Type>;
                friend class Hashmap;
                
            public:
                Iterator_() {
                }
                Iterator_(const Iterator_ &it) : currentit(it.currentit), container(it.container) {
                }
                
                void Remove() {
                    if(container==nullptr) {
                        throw std::runtime_error("Iterator is not valid.");
                    }
                    
                    currentit=container->mapping.erase(current());
                }
                
                void Delete() {
                    if(container==nullptr) {
                        throw std::runtime_error("Iterator is not valid.");
                    }
                    
                    auto item=currentit->second;
                    
                    currentit=container->mapping.erase(currentit);
                    delete item;
                }               
                
                void SetItem(typename H_::ValueType &newitem, bool deleteprev=false) {
                    if(deleteprev) {
                        delete currentit->second;
                    }
                    currentit->second=&newitem;
                }
                
            protected:
                Iterator_(H_ &container, const I_ iterator) : currentit(iterator), container(&container) {
                }
                
            protected:
                Type current() const {
                    if(!isvalid())
                        throw std::out_of_range("Iterator is not valid.");
                    
                    return {currentit->first, *(currentit->second)};
                }
                
                bool isvalid() const {
                    if(container==nullptr) return false;
                    
                    return currentit!=container->mapping.end();
                }
                
                bool moveby(long amount) {
                    if(container==nullptr) return false;
 
                    //sanity check
                    if(amount==0)  return isvalid();
                    
                    if(amount>0) {
                        for(int i=0;i<amount;i++)
                            ++currentit;
                    }
                    else {
                        for(int i=amount;i<0;i++)
                            --currentit;
                    }
                    
                    return isvalid();
                }
                
                bool compare(const Iterator_ &it) const {
                    return it.currentit==currentit;
                }
                
                void set(const Iterator_ &it) {
                    currentit=it.currentit;
                    container=it.container;
                }
                
                long distance(const Iterator_ &it) const {
                    return it.currentit-currentit;
                }
                
                bool isbefore(const Iterator_ &it) const {
                    return currentit<it.currentit;
                }
                
            public:
                
                Iterator_ &operator =(const Iterator_ &iterator) {
                    set(iterator);
                    
                    return *this;
                }
                
            protected:
                I_ currentit;
                H_ *container = nullptr;
            };
            
            template<class I_, class H_>
            friend class Iterator_;
            
        public:
            typedef T_ ValueType;
            typedef K_ KeyType;
            
            typedef Iterator_<typename std::map<K_, T_*>::iterator, Hashmap> Iterator;
            
            class ConstIterator : public Iterator_<typename MapType::const_iterator, const Hashmap> {
                friend class Hashmap;
            public:
                ConstIterator(const Iterator &it) {
                    this->currentit=it.currentit;
                    this->container=it.container;
                }
                
            private:
                ConstIterator(const Hashmap &h, const typename MapType::const_iterator it) : 
                Iterator_<typename MapType::const_iterator, const Hashmap>(h, it) {
                }
                
                void Remove() {}
                void Delete() {}
                void SetKey(const K_ &newkey) {}
            };
            
            
            Hashmap() { }
            
            Hashmap(std::initializer_list<std::pair<const K_, T_*>> list) : mapping(list) {
#ifndef NDEBUG
                for(auto &p : list) {
                    assert(p.second && "Element is nullptr");
                }
#endif
            }
            
            Hashmap(std::initializer_list<std::pair<const K_, T_&>> list) {
                for(auto &p : list) {
                    mapping.insert(std::make_pair(p.first, &p.second));
                }
            }
            
            Hashmap(std::initializer_list<T_*> list) {
                assert(KeyFn && "Key retrieval function should be set.");
                
                for(auto &p : list) {
                    if(p) {
                        mapping.insert(std::make_pair(KeyFn(*p), p));
                    }
                }
            }
            
            Hashmap(const Hashmap &) = delete;
            
            Hashmap(Hashmap &&other) {
                Swap(other);
            }
            
            Hashmap Duplicate() const {
                Hashmap ret;
                ret.mapping=mapping;
                
                return ret;
            }
            
            void Swap(Hashmap &other) {
                using std::swap;
                
                swap(mapping, other.mapping);
            }
            
            Hashmap &operator= (const Hashmap &other) = delete;
            
            Hashmap &operator= (Hashmap &&other) {
                RemoveAll();
                Swap(other);
                
                return *this;
            }
            
            void Add(const K_ &key, T_ &obj, bool deleteprev = false) {
                auto it = mapping.find(key);
                if( it != mapping.end() ) {
                    if(deleteprev) {
                        delete it->second;
                    }
                    it->second = &obj;
                }
                else {
                    mapping.insert(std::make_pair(key, &obj));
                }
            }
            
            void Add(const K_ &key, T_ *obj, bool deleteprev = false) {
                if(obj) {
                    auto it = mapping.find(key);
                    if( it != mapping.end() ) {
                        if(deleteprev) {
                            delete it->second;
                        }
                        it->second = obj;
                    }
                    else {
                        mapping.insert(std::make_pair(key, obj));
                    }
                }
                else {
                    auto it = mapping.find(key);
                    if( it != mapping.end() ) {
                        if(deleteprev) {
                            delete it->second;
                        }
                        mapping.erase(it);
                    }
                }
            }
            
            void Add(T_ &obj, bool deleteprev=false) {
                assert(KeyFn!=nullptr && "Key retrieval function should be set.");
                
                Add(KeyFn(obj), obj, deleteprev);
            }
            
            void Add(T_ *obj, bool deleteprev=false) {
                assert(KeyFn!=nullptr && "Key retrieval function should be set.");
                
                if(obj)
                    Add(KeyFn(*obj), obj, deleteprev);
                else
                    Add({}, obj, deleteprev);
            }
            
            void Remove(const K_ &key) {
                mapping.erase(key);
            }
            
            void Delete(const K_ &key) {
                auto it = mapping.find(key);
                if(it!=mapping.end()) {
                    delete it->second;
                    mapping.erase(it);
                }
            }
            
            void RemoveAll() {
                mapping.clear();
            }
            
            void Collapse() {
                decltype(mapping) newmap;
                
                using std::swap;
                swap(mapping, newmap);
            }
                
            
            void DeleteAll() {
                for(auto &p : mapping) {
                    delete p.second;
                }
                
                mapping.clear();
            }
            
            void Destroy() {
                for(auto &p : mapping) {
                    delete p.second;
                }
                
                Collapse();
            }
            
            long GetCount() const {
                return (long)mapping.size();
            }
            
            long GetSize() const {
                return (long)mapping.size();
            }
            
            T_ &operator [](const K_ &key) const {
                auto it = mapping.find(key);
                
                if(it == mapping.end()) {
                    properthrow(key);
                }
                
                return *(it->second);
            }
            
            bool Exists(const K_ &key) const {
                return mapping.count(key)!=0;
            }
            
            Iterator Find(const K_ &key) {
                return Iterator(*this, mapping.find(key));
            }
            
            ConstIterator Find(const K_ &key) const {
                return ConstIterator(*this, mapping.find(key));
            }
            
            Iterator begin() {
                return Iterator(*this, mapping.begin());
            }
            
            Iterator end() {
                return Iterator(*this, mapping.end());
            }
            
            Iterator First() {
                return Iterator(*this, mapping.begin());
            }
            
            Iterator Last() {
                auto it = mapping.end();
                if(mapping.size()>0)
                    --it;
 
                return Iterator(*this, it);
            }
            
            ConstIterator begin() const {
                return ConstIterator(*this, mapping.begin());
            }
            
            ConstIterator end() const {
                return ConstIterator(*this, mapping.end());
            }
            
            ConstIterator First() const {
                return ConstIterator(*this, mapping.begin());
            }
            
            ConstIterator Last() const {
                auto it = mapping.end();
                if(mapping.size()>0)
                    --it;
 
                return ConstIterator(*this, it);
            }
            
            
            
        private:
            
            template<class K__>
            typename std::enable_if<TMP::IsStreamable<K__>::Value, void>::type properthrow(const K__ &key) const {
                std::stringstream ss;
                ss<<"Item not found: ";
                ss<<key;
#ifdef TEST
                ASSERT(false, ss.str(), 0, 8);
#endif
                throw std::runtime_error(ss.str());
            }
            
            template<class K__>
            typename std::enable_if<!TMP::IsStreamable<K__>::Value, void>::type properthrow(const K__ &key) const {
#ifdef TEST
                ASSERT(false, "Item not found", 0, 8);
#endif
                throw std::runtime_error("Item not found");
            }
            
            MapType mapping;
        };
        
        template<class K_, class T_, K_ (KeyFn)(const T_&)=nullptr, template <class ...> class M_=std::map, class C_=std::less<K_>>
        void swap(Hashmap<K_, T_, KeyFn, M_, C_> &left, Hashmap<K_, T_, KeyFn, M_, C_> &right) {
            left.Swap(right);
        }
        
    }
}