Kwave::LRU_Cache< IDX, DATA > Class Template Reference

#include <LRU_Cache.h>

Inheritance diagram for Kwave::LRU_Cache< IDX, DATA >:

Collaboration diagram for Kwave::LRU_Cache< IDX, DATA >:

Public Member Functions
	LRU_Cache ()
virtual	~LRU_Cache ()
bool	isEmpty () const
const DATA &	operator[] (const IDX index) const
DATA &	operator[] (const IDX index)
bool	contains (const IDX index) const
void	remove (const IDX index)
void	insert (const IDX index, DATA &value)
QList< IDX >	keys () const
QList< DATA >	values () const

Private Types
typedef QPair< IDX, DATA >	Pair

Detailed Description

template<class IDX, class DATA>
class Kwave::LRU_Cache< IDX, DATA >

Definition at line 30 of file LRU_Cache.h.

Member Typedef Documentation

Pair

template<class IDX, class DATA>

typedef QPair<IDX,DATA> Kwave::LRU_Cache< IDX, DATA >::Pair

private

internal typedef for the QPair

Definition at line 35 of file LRU_Cache.h.

Constructor & Destructor Documentation

LRU_Cache()

template<class IDX, class DATA>

Kwave::LRU_Cache< IDX, DATA >::LRU_Cache ( )

inline

Constructor

Definition at line 39 of file LRU_Cache.h.

            :QLinkedList< Pair >()
        {
        }

~LRU_Cache()

template<class IDX, class DATA>

virtual Kwave::LRU_Cache< IDX, DATA >::~LRU_Cache ( )

inlinevirtual

Destructor

Definition at line 45 of file LRU_Cache.h.

        {
        }

Member Function Documentation

contains()

template<class IDX, class DATA>

bool Kwave::LRU_Cache< IDX, DATA >::contains ( const IDX  index ) const

inline

checks whether an index is contained

Parameters

index

the index (key) of the element to look up

Returns

true if found, otherwise false

Definition at line 97 of file LRU_Cache.h.

        {
            foreach(const Pair &p, *this) {
                if (p.first == index)
                    return true;
            }
            return false;
        }

insert()

template<class IDX, class DATA>

void Kwave::LRU_Cache< IDX, DATA >::insert ( const IDX  index, DATA &  value  )

inline

insert a new entry to the start of the list (newest)

Parameters

index	the index (key) of the element to insert
value	the data of the element to insert

Definition at line 129 of file LRU_Cache.h.

Referenced by Kwave::LRU_Cache< Kwave::Handle, Kwave::MemoryManager::physical_memory_t >::operator[]().

        {
            QLinkedList<Pair>::prepend(Pair(index, value));
        }

Here is the caller graph for this function:

isEmpty()

template<class IDX, class DATA>

bool Kwave::LRU_Cache< IDX, DATA >::isEmpty ( ) const

inline

returns true if the cache is empty

Definition at line 50 of file LRU_Cache.h.

                             {
            return QLinkedList<Pair>::isEmpty();
        }

keys()

template<class IDX, class DATA>

QList<IDX> Kwave::LRU_Cache< IDX, DATA >::keys ( ) const

inline

returns a list of keys

Definition at line 135 of file LRU_Cache.h.

        {
            QList<IDX> i;
            foreach(const Pair &p, *this) {
                i << p.first;
            }
            return i;
        }

operator[]() [1/2]

template<class IDX, class DATA>

const DATA& Kwave::LRU_Cache< IDX, DATA >::operator[] ( const IDX  index ) const

inline

index operator, const

Definition at line 55 of file LRU_Cache.h.

        {
            foreach(const Pair &p, *this) {
                if (p.first == index) {
                    return p.second;
                }
            }
            return DATA();
        }

operator[]() [2/2]

template<class IDX, class DATA>

DATA& Kwave::LRU_Cache< IDX, DATA >::operator[] ( const IDX  index )

inline

index operator, non-const

Definition at line 66 of file LRU_Cache.h.

        {
            static DATA dummy;

            if (!QLinkedList<Pair>::isEmpty()) {
                QMutableLinkedListIterator<Pair> it(*this);
                while (it.hasNext()) {
                    Pair &p = it.next();
                    if (p.first == index) {
                        if (p.first != QLinkedList<Pair>::first().first) {
                            // found it -> move the entry to the start of the list
                            Pair pair = p;
                            it.remove();
                            insert(pair.first, pair.second);
//                          qDebug("Kwave::MemoryManager[%9d] - reordering",
//                                 pair.first);
                        }

                        // get the newly entered entry again
                        return QLinkedList<Pair>::first().second;
                    }
                }
            }
            return dummy;
        }

remove()

template<class IDX, class DATA>

void Kwave::LRU_Cache< IDX, DATA >::remove ( const IDX  index )

inline

remove an entry

Parameters

index

the index (key) of the element to remove

Definition at line 110 of file LRU_Cache.h.

        {
            if (!QLinkedList<Pair>::isEmpty()) {
                QMutableLinkedListIterator<Pair> it(*this);
                while (it.hasNext()) {
                    Pair &p = it.next();
                    if (p.first == index) {
                        it.remove();
                        break;
                    }
                }
            }
        }

values()

template<class IDX, class DATA>

QList<DATA> Kwave::LRU_Cache< IDX, DATA >::values ( ) const

inline

returns a list of values

Definition at line 145 of file LRU_Cache.h.

        {
            QList<DATA> v;
            foreach(const Pair &p, *this) {
                v << p.second;
            }
            return v;
        }

---

The documentation for this class was generated from the following file:

• libkwave/LRU_Cache.h