ObjectCache.h

#pragma once


#include <libutl/Hashtable.h>
#include <libutl/List.h>


UTL_NS_BEGIN;


enum cache_t
{
    cache_write_thru, 
    cache_write_back  
};

// CachedObject ////////////////////////////////////////////////////////////////////////////////////


class CachedObject : public Object
{
    UTL_CLASS_DECL(CachedObject, Object);

public:
    void
    set(const Object* object, const ListNode* node)
    {
        _object = const_cast<Object*>(object);
        _node = const_cast<ListNode*>(node);
        _dirty = false;
    }

    virtual const Object&
    getKey() const
    {
        ASSERTD(_object != nullptr);
        return _object->getKey();
    }

    ListNode*
    getNode() const
    {
        return _node;
    }

    Object*
    getObject() const
    {
        return _object;
    }

    bool
    isDirty() const
    {
        return _dirty;
    }

    void
    setDirty(bool dirty)
    {
        _dirty = dirty;
    }

private:
    void
    init()
    {
    }
    void
    deInit()
    {
        delete _object;
    }

private:
    Object* _object;
    ListNode* _node;
    bool _dirty;
};

// ObjectCache /////////////////////////////////////////////////////////////////////////////////////


class ObjectCache : public Collection
{
    UTL_CLASS_DECL(ObjectCache, Collection);
    UTL_CLASS_NO_COPY;
    UTL_CLASS_NO_SERIALIZE;

public:
    ObjectCache(size_t size)
    {
        init(size);
    }

    void access(const Object* object);

    virtual bool
    add(const Object* object)
    {
        return addCache(object);
    }

    ListIt
    begin() const
    {
        return _list.begin();
    }

    virtual BidIt*
    beginNew() const
    {
        return _list.beginNew();
    }

    virtual BidIt*
    beginNew()
    {
        return _list.beginNew();
    }

    virtual void
    clear()
    {
        _ht.clear();
        _list.clear();
        _items = 0;
    }

    ListIt
    end() const
    {
        return _list.end();
    }

    virtual BidIt*
    endNew() const
    {
        return _list.endNew();
    }

    virtual BidIt*
    endNew()
    {
        return _list.endNew();
    }

    virtual Object*
    find(const Object& key) const
    {
        return find(key, isFrozen());
    }

    CachedObject* find(const Object& key, bool frozen) const;

    ListIt findIt(const Object& key) const;

    void
    findIt(const Object& key, BidIt& it) const
    {
        const_cast_this->findIt(key, it);
        IFDEBUG(it.setConst(true));
    }

    virtual void findIt(const Object& key, BidIt& it);

    Object*
    getLRU() const
    {
        return _list.last();
    }

    Object*
    getMRU() const
    {
        return _list.first();
    }

    size_t
    getSize() const
    {
        return _size;
    }

    bool
    isFrozen() const
    {
        return getFlag(flg_frozen);
    }

    bool
    isFull() const
    {
        return (_list.items() == _size);
    }

    bool
    remove(const Object* key)
    {
        ASSERTD(key != nullptr);
        return remove(*key);
    }

    virtual bool
    remove(const Object& key)
    {
        return removeCache(key);
    }

    virtual void removeIt(BidIt& it);

    void set(size_t size);

    void
    setFrozen(bool frozen)
    {
        setFlag(flg_frozen, frozen);
    }

public:
    typedef ListIt iterator;

private:
    void
    init(size_t size = 1024)
    {
        _size = size;
        _list.setOwner(false);
    }
    void
    deInit()
    {
        clear();
    }
    void access(ListNode* node) const;
    bool addCache(const Object* object);
    bool removeCache(const Object* object);

private:
    size_t _size;
    Hashtable _ht;
    mutable List _list;
    enum flg_t
    {
        flg_frozen = 4
    };
};


UTL_NS_END;