AliasCache.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_ALIASCACHE_HXX_
#define _OPENLCB_ALIASCACHE_HXX_
 
#include "openlcb/Defs.hxx"
#include "utils/Map.hxx"
#include "utils/SortedListMap.hxx"
#include "utils/macros.h"
 
namespace openlcb
{
 
class AliasCache
{
public:
    AliasCache(NodeID seed, size_t _entries,
        void (*remove_callback)(NodeID id, NodeAlias alias, void *) = NULL,
        void *context = NULL)
        : pool(new Metadata[_entries])
        , aliasMap(this)
        , idMap(this)
        , seed(seed)
        , entries(_entries)
        , removeCallback(remove_callback)
        , context(context)
    {
        aliasMap.reserve(_entries);
        idMap.reserve(_entries);
        clear();
    }
 
    static constexpr uint16_t NONE_ENTRY = 0xFFFFu;
 
    void clear();
 
    void add(NodeID id, NodeAlias alias);
    
    void remove(NodeAlias alias);
 
    NodeAlias lookup(NodeID id);
 
    NodeID lookup(NodeAlias alias);
 
    void for_each(void (*callback)(void*, NodeID, NodeAlias), void *context);
 
    size_t size()
    {
        return entries;
    }
 
    bool retrieve(unsigned entry, NodeID* node, NodeAlias* alias);
 
    bool next_entry(NodeID bound, NodeID *node, NodeAlias *alias);
 
    NodeAlias generate();
 
    ~AliasCache()
    {
        delete [] pool;
    }
 
    int check_consistency();
 
private:
    struct Metadata;
    class PoolIdx;
    friend class PoolIdx;
 
    class PoolIdx
    {
    public:
        PoolIdx()
            : idx_(NONE_ENTRY)
        {
        }
        bool empty()
        {
            return idx_ == NONE_ENTRY;
        }
        uint16_t idx_;
        Metadata *deref(AliasCache *parent)
        {
            DASSERT(idx_ != NONE_ENTRY);
            return parent->pool + idx_;
        }
    };
 
    struct Metadata
    {
        void set_node_id(NodeID id)
        {
            nodeIdLow_ = id & 0xFFFFFFFFu;
            nodeIdHigh_ = (id >> 32) & 0xFFFFu;
        }
 
        NodeID get_node_id()
        {
            uint64_t h = nodeIdHigh_;
            h <<= 32;
            h |= nodeIdLow_;
            return h;
        }
 
        uint32_t nodeIdLow_ = 0;
        uint16_t nodeIdHigh_ = 0;
        NodeAlias alias_ = 0;
        PoolIdx newer_;
        PoolIdx older_;
    };
 
    Metadata *pool;
 
    class AliasComparator
    {
    public:
        AliasComparator(AliasCache *parent)
            : parent_(parent)
        {
        }
 
        bool operator()(PoolIdx e, uint16_t alias) const
        {
            return e.deref(parent_)->alias_ < alias;
        }
 
        bool operator()(uint16_t alias, PoolIdx e) const
        {
            return alias < e.deref(parent_)->alias_;
        }
 
        bool operator()(PoolIdx a, PoolIdx b) const
        {
            return a.deref(parent_)->alias_ < b.deref(parent_)->alias_;
        }
 
    private:
        AliasCache *parent_;
    };
 
    class IdComparator
    {
    public:
        IdComparator(AliasCache *parent)
            : parent_(parent)
        {
        }
 
        bool operator()(PoolIdx e, NodeID id) const
        {
            return e.deref(parent_)->get_node_id() < id;
        }
 
        bool operator()(NodeID id, PoolIdx e) const
        {
            return id < e.deref(parent_)->get_node_id();
        }
 
        bool operator()(PoolIdx a, PoolIdx b) const
        {
            return a.deref(parent_)->get_node_id() <
                b.deref(parent_)->get_node_id();
        }
 
    private:
        AliasCache *parent_;
    };
 
    typedef SortedListSet<PoolIdx, AliasComparator> AliasMap;
 
    typedef SortedListSet<PoolIdx, IdComparator> IdMap;
 
    AliasMap aliasMap;
    
    IdMap idMap;
 
    PoolIdx freeList;
 
    PoolIdx oldest;
 
    PoolIdx newest;
 
    NodeID seed;
 
    size_t entries;
 
    void (*removeCallback)(NodeID id, NodeAlias alias, void *);
    
    void *context;
 
    void touch(Metadata* metadata);
 
    DISALLOW_COPY_AND_ASSIGN(AliasCache);
};
 
} /* namespace openlcb */
 
#endif  // _OPENLCB_ALIASCACHE_HXX_