RefMgr< TO, FROM > Class Template Reference

#include "RefMgr.h"

Inheritance diagram for RefMgr< TO, FROM >:

Public Types
typedef LinkedListHead::Iterator< Reference< TO, FROM > >	iterator
Public Types inherited from LinkedListHead
typedef Iterator< LinkedListElement >	iterator

Public Member Functions
	RefMgr ()=default
virtual	~RefMgr ()
Reference< TO, FROM > *	getFirst ()
Reference< TO, FROM > const *	getFirst () const
Reference< TO, FROM > *	getLast ()
Reference< TO, FROM > const *	getLast () const
iterator	begin ()
iterator	end ()
iterator	rbegin ()
iterator	rend ()
void	clearReferences ()
Public Member Functions inherited from LinkedListHead
	LinkedListHead ()
bool	IsEmpty () const
LinkedListElement *	getFirst ()
LinkedListElement const *	getFirst () const
LinkedListElement *	getLast ()
LinkedListElement const *	getLast () const
void	insertFirst (LinkedListElement *pElem)
void	insertLast (LinkedListElement *pElem)
uint32	getSize () const
void	incSize ()
void	decSize ()

Detailed Description

template<class TO, class FROM>
class RefMgr< TO, FROM >

Member Typedef Documentation

iterator

template<class TO , class FROM >

typedef LinkedListHead::Iterator< Reference<TO, FROM> > RefMgr< TO, FROM >::iterator

Constructor & Destructor Documentation

RefMgr()

template<class TO , class FROM >

RefMgr< TO, FROM >::RefMgr ( )

default

~RefMgr()

template<class TO , class FROM >

virtual RefMgr< TO, FROM >::~RefMgr ( )

inlinevirtual

{ clearReferences(); }

References RefMgr< TO, FROM >::clearReferences().

Member Function Documentation

begin()

template<class TO , class FROM >

iterator RefMgr< TO, FROM >::begin ( )

inline

{ return iterator(getFirst()); }

References RefMgr< TO, FROM >::getFirst().

clearReferences()

template<class TO , class FROM >

void RefMgr< TO, FROM >::clearReferences ( )

inline

    {
        LinkedListElement* ref;
        while ((ref = getFirst()) != nullptr)
        {
            ((Reference<TO, FROM>*) ref)->invalidate();
            ref->delink();                              // the delink might be already done by invalidate(), but doing it here again does not hurt and insures an empty list
        }
    }

References LinkedListElement::delink(), and RefMgr< TO, FROM >::getFirst().

Referenced by Loot::clear(), and RefMgr< TO, FROM >::~RefMgr().

end()

template<class TO , class FROM >

iterator RefMgr< TO, FROM >::end ( )

inline

{ return iterator(nullptr); }

getFirst() [1/2]

template<class TO , class FROM >

Reference< TO, FROM > * RefMgr< TO, FROM >::getFirst ( )

inline

{ return ((Reference<TO, FROM>*) LinkedListHead::getFirst()); }

References LinkedListHead::getFirst().

Referenced by RefMgr< TO, FROM >::begin(), RefMgr< TO, FROM >::clearReferences(), LootValidatorRefMgr::getFirst(), and MapRefMgr::getFirst().

getFirst() [2/2]

template<class TO , class FROM >

Reference< TO, FROM > const * RefMgr< TO, FROM >::getFirst ( ) const

inline

{ return ((Reference<TO, FROM> const*) LinkedListHead::getFirst()); }

References LinkedListHead::getFirst().

getLast() [1/2]

template<class TO , class FROM >

Reference< TO, FROM > * RefMgr< TO, FROM >::getLast ( )

inline

{ return ((Reference<TO, FROM>*) LinkedListHead::getLast()); }

References LinkedListHead::getLast().

Referenced by LootValidatorRefMgr::getLast(), MapRefMgr::getLast(), and RefMgr< TO, FROM >::rbegin().

getLast() [2/2]

template<class TO , class FROM >

Reference< TO, FROM > const * RefMgr< TO, FROM >::getLast ( ) const

inline

{ return ((Reference<TO, FROM> const*) LinkedListHead::getLast()); }

References LinkedListHead::getLast().

rbegin()

template<class TO , class FROM >

iterator RefMgr< TO, FROM >::rbegin ( )

inline

{ return iterator(getLast()); }

References RefMgr< TO, FROM >::getLast().

rend()

template<class TO , class FROM >

iterator RefMgr< TO, FROM >::rend ( )

inline

{ return iterator(nullptr); }