template class Poco::ExpireStrategy

Overview

An ExpireStrategy implements time based expiration of cache entries. More…

#include <ExpireStrategy.h>

template <
    class TKey,
    class TValue
    >
class ExpireStrategy: public Poco::AbstractStrategy
{
public:
    // typedefs

    typedef std::multimap<Timestamp, TKey> TimeIndex;
    typedef TimeIndex::iterator IndexIterator;
    typedef TimeIndex::const_iterator ConstIndexIterator;
    typedef std::map<TKey, IndexIterator> Keys;
    typedef Keys::iterator Iterator;

    // construction

    ExpireStrategy(Timestamp::TimeDiff expireTimeInMilliSec);

    // methods

    virtual
    void
    onAdd(
        const void* pSender,
        const KeyValueArgs<TKey, TValue>& key
        );

    virtual
    void
    onRemove(
        const void* pSender,
        const TKey& key
        );

    virtual
    void
    onGet(
        const void* pSender,
        const TKey& key
        );

    virtual
    void
    onClear(
        const void* pSender,
        const EventArgs& args
        );

    virtual
    void
    onIsValid(
        const void* pSender,
        ValidArgs<TKey>& key
        );

    virtual
    void
    onReplace(
        const void* pSender,
        std::set<TKey>& elemsToRemove
        );

protected:
    // fields

    Timestamp::TimeDiff _expireTime;
    Keys _keys;
    TimeIndex _keyIndex;
};

// direct descendants

template <
    class TKey,
    class TValue
    >
class AccessExpireStrategy;

Inherited Members

public:
    // methods

    virtual
    void
    onUpdate(
        const void* pSender,
        const KeyValueArgs<TKey, TValue>& args
        );

    virtual
    void
    onAdd(
        const void* pSender,
        const KeyValueArgs<TKey, TValue>& key
        ) = 0;

    virtual
    void
    onRemove(
        const void* pSender,
        const TKey& key
        ) = 0;

    virtual
    void
    onGet(
        const void* pSender,
        const TKey& key
        ) = 0;

    virtual
    void
    onClear(
        const void* pSender,
        const EventArgs& args
        ) = 0;

    virtual
    void
    onIsValid(
        const void* pSender,
        ValidArgs<TKey>& key
        ) = 0;

    virtual
    void
    onReplace(
        const void* pSender,
        std::set<TKey>& elemsToRemove
        ) = 0;

Detailed Documentation

An ExpireStrategy implements time based expiration of cache entries.

Fields

Keys _keys

For faster replacement of keys, the iterator points to the _keyIndex map.

TimeIndex _keyIndex

Maps time to key value.

Construction

ExpireStrategy(Timestamp::TimeDiff expireTimeInMilliSec)

Create an expire strategy.

Note that the smallest allowed caching time is 25ms. Anything lower than that is not useful with current operating systems.

Methods

virtual
void
onAdd(
    const void* pSender,
    const KeyValueArgs<TKey, TValue>& key
    )

Adds the key to the strategy.

If for the key already an entry exists, an exception will be thrown.

virtual
void
onRemove(
    const void* pSender,
    const TKey& key
    )

Removes an entry from the strategy.

If the entry is not found the remove is ignored.

virtual
void
onGet(
    const void* pSender,
    const TKey& key
    )

Informs the strategy that a read-access happens to an element.

virtual
void
onClear(
    const void* pSender,
    const EventArgs& args
    )

Removes all elements from the cache.

virtual
void
onIsValid(
    const void* pSender,
    ValidArgs<TKey>& key
    )

Used to query if a key is still valid (i.e. cached).

virtual
void
onReplace(
    const void* pSender,
    std::set<TKey>& elemsToRemove
    )

Used by the Strategy to indicate which elements should be removed from the cache.

Note that onReplace does not change the current list of keys. The cache object is reponsible to remove the elements.