NodeHandlerMap.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_NODEHANDLERMAP_HXX_
#define _UTILS_NODEHANDLERMAP_HXX_
 
#include <stdint.h>
#include <utility>
 
#include "utils/StlMap.hxx"
#include "utils/LinearMap.hxx"
#include "utils/SysMap.hxx"
 
 
#if UINTPTR_MAX > UINT32_MAX
#define NODEHANDLER_USE_PAIR
#endif
 
 
class NodeHandlerMapBase
{
private:
#ifdef NODEHANDLER_USE_PAIR
    typedef std::pair<void*, uint32_t> key_type;
#else
    typedef uint64_t key_type;
#endif
    typedef void* value_type;
    typedef StlMap<key_type, value_type> map_type;
 
public:
    NodeHandlerMapBase()
    {
    }
 
    NodeHandlerMapBase(size_t entries) : entries_(entries)
    {
    }
 
    void insert(void* node, uint32_t id, void* value)
    {
        entries_[make_key(node, id)] = value;
    }
 
    void erase(void *node, uint32_t id, void *value)
    {
        auto it = entries_.find(make_key(node, id));
        if (it == entries_.end()) return;
        if (it->second == value) {
            entries_.erase(it);
        }
    }
    
    void* lookup(void* node, uint32_t id)
    {
        auto it = entries_.find(make_key(node, id));
        if (it == entries_.end())
        {
            it = entries_.find(make_key(nullptr, id));
        }
        if (it == entries_.end())
        {
            return nullptr;
        }
        else
        {
            return it->second;
        }
    }
 
    typedef typename map_type::Iterator iterator;
    iterator begin()
    {
        return entries_.begin();
    }
 
    iterator end()
    {
        return entries_.end();
    }
 
    static pair<void *, uint32_t> read_key(key_type key)
    {
#ifdef NODEHANDLER_USE_PAIR
        return key;
#else
        uint32_t id = key & 0xFFFFFFFFU;
        uint32_t n = key >> 32;
        return std::make_pair(reinterpret_cast<void *>(n), id);
#endif
    }
 
private:
    key_type make_key(void* node, uint32_t id)
    {
#ifdef NODEHANDLER_USE_PAIR
        return std::make_pair(node, id);
#else
        uint64_t key = reinterpret_cast<uint32_t>(node);
        key <<= 32;
        key |= id;
        return key;
#endif
    }
 
    map_type entries_;
};
 
template <class Node, class Handler>
class TypedNodeHandlerMap : private NodeHandlerMapBase
{
public:
    TypedNodeHandlerMap()
    {
    }
 
    TypedNodeHandlerMap(size_t entries) : NodeHandlerMapBase(entries)
    {
    }
 
    void insert(Node* node, uint32_t id, Handler* handler)
    {
        NodeHandlerMapBase::insert(node, id, handler);
    }
 
    void erase(Node* node, uint32_t id, Handler* handler)
    {
        NodeHandlerMapBase::erase(node, id, handler);
    }
 
    Handler* lookup(Node* node, uint32_t id)
    {
        return static_cast<Handler*>(NodeHandlerMapBase::lookup(node, id));
    }
 
    class iterator {
    public:
        iterator(NodeHandlerMapBase::iterator i)
            : impl_(i) {}
        
        void operator++() {
            ++impl_;
        }
 
        bool operator!=(const iterator& o) {
            return impl_ != o.impl_;
        }
 
        std::pair<std::pair<Node*, uint32_t>, Handler*> operator*() {
            auto p = NodeHandlerMapBase::read_key(impl_->first);
            return std::make_pair(std::make_pair((Node*) p.first, p.second),
                                  (Handler*)impl_->second);
        }
 
    private:
        NodeHandlerMapBase::iterator impl_;
    };
 
    iterator begin() {
        return iterator(NodeHandlerMapBase::begin());
    }
 
    iterator end() {
        return iterator(NodeHandlerMapBase::end());
    }
};
 
#endif // _UTILS_NODEHANDLERMAP_HXX_