588 lines
16 KiB
C++
588 lines
16 KiB
C++
#pragma once
|
|
|
|
#include "fusiontrace.h"
|
|
#include "fusiondequelinkage.h"
|
|
|
|
class CDequeBase
|
|
{
|
|
protected:
|
|
inline CDequeBase() : m_EntryCount(0) { m_Head.InitializeHead(this); }
|
|
|
|
inline ~CDequeBase()
|
|
{
|
|
// Derived class should have cleaned up
|
|
ASSERT_NTC(m_EntryCount == 0);
|
|
}
|
|
|
|
inline VOID VerifyLinkageFromThisDeque(const CDequeLinkage &r)
|
|
{
|
|
ASSERT_NTC(r.GetDequeBase() == this);
|
|
}
|
|
|
|
#if DBG
|
|
inline bool Valid() const { return (m_Head.GetFlink() != NULL) && (m_Head.GetBlink() != NULL); }
|
|
#endif // DBG
|
|
|
|
void ResetHead() { FN_TRACE(); m_Head.InitializeHead(this); }
|
|
|
|
inline VOID InsertAfter(CDequeLinkage *pExistingLinkage, CDequeLinkage *pNewLinkage, bool fUpdateEntryCount = true)
|
|
{
|
|
ASSERT_NTC(this->Valid());
|
|
this->VerifyLinkageFromThisDeque(m_Head);
|
|
|
|
pNewLinkage->SetFlink(pExistingLinkage->GetFlink());
|
|
pNewLinkage->SetBlink(pExistingLinkage);
|
|
pExistingLinkage->GetFlink()->SetBlink(pNewLinkage);
|
|
pExistingLinkage->SetFlink(pNewLinkage);
|
|
pNewLinkage->SetDeque(this);
|
|
if (fUpdateEntryCount)
|
|
m_EntryCount++;
|
|
}
|
|
|
|
VOID InsertBefore(CDequeLinkage *pExistingLinkage, CDequeLinkage *pNewLinkage, bool fUpdateEntryCount = true)
|
|
{
|
|
ASSERT_NTC(this->Valid());
|
|
this->VerifyLinkageFromThisDeque(m_Head);
|
|
|
|
pNewLinkage->SetBlink(pExistingLinkage->GetBlink());
|
|
pNewLinkage->SetFlink(pExistingLinkage);
|
|
pExistingLinkage->GetBlink()->SetFlink(pNewLinkage);
|
|
pExistingLinkage->SetBlink(pNewLinkage);
|
|
pNewLinkage->SetDeque(this);
|
|
if (fUpdateEntryCount)
|
|
m_EntryCount++;
|
|
}
|
|
|
|
VOID Remove(CDequeLinkage *pLinkage, bool fUpdateEntryCount = true)
|
|
{
|
|
ASSERT_NTC(this->Valid());
|
|
this->VerifyLinkageFromThisDeque(m_Head);
|
|
|
|
// You can't remove the head...
|
|
ASSERT_NTC(pLinkage->GetDequeBase() == this);
|
|
ASSERT_NTC(pLinkage != &m_Head);
|
|
ASSERT_NTC(pLinkage->m_ulLockCount == 0);
|
|
|
|
if ((pLinkage != NULL) &&
|
|
(pLinkage->GetDequeBase() == this) &&
|
|
(pLinkage != &m_Head))
|
|
{
|
|
pLinkage->GetBlink()->SetFlink(pLinkage->GetFlink());
|
|
pLinkage->GetFlink()->SetBlink(pLinkage->GetBlink());
|
|
if (fUpdateEntryCount)
|
|
m_EntryCount--;
|
|
}
|
|
}
|
|
|
|
VOID SetDeque(CDequeLinkage *pLinkage) { pLinkage->SetDeque(this); }
|
|
|
|
static CDequeLinkage *GetFlink(const CDequeLinkage *pLinkage) { return pLinkage->GetFlink(); }
|
|
static CDequeLinkage *GetFlink(const CDequeLinkage &rLinkage) { return rLinkage.GetFlink(); }
|
|
static CDequeLinkage *GetBlink(const CDequeLinkage *pLinkage) { return pLinkage->GetBlink(); }
|
|
static CDequeLinkage *GetBlink(const CDequeLinkage &rLinkage) { return rLinkage.GetBlink(); }
|
|
static VOID SetFlink(CDequeLinkage *pLinkage, CDequeLinkage *pFlink) { pLinkage->SetFlink(pFlink); }
|
|
static VOID SetFlink(CDequeLinkage &rLinkage, CDequeLinkage *pFlink) { rLinkage.SetFlink(pFlink); }
|
|
static VOID SetBlink(CDequeLinkage *pLinkage, CDequeLinkage *pBlink) { pLinkage->SetBlink(pBlink); }
|
|
static VOID SetBlink(CDequeLinkage &rLinkage, CDequeLinkage *pBlink) { rLinkage.SetBlink(pBlink); }
|
|
|
|
CDequeLinkage m_Head;
|
|
SIZE_T m_EntryCount;
|
|
|
|
private:
|
|
CDequeBase(const CDequeBase &r); // intentionally not implemented
|
|
void operator =(const CDequeBase &r); // intentionally not implemented
|
|
};
|
|
|
|
template <typename TEntry, size_t LinkageMemberOffset> class CConstDequeIterator;
|
|
|
|
template <typename TEntry, size_t LinkageMemberOffset> class CDeque : protected CDequeBase
|
|
{
|
|
friend CConstDequeIterator<TEntry, LinkageMemberOffset>;
|
|
|
|
public:
|
|
CDeque() { }
|
|
|
|
~CDeque()
|
|
{
|
|
CSxsPreserveLastError ple;
|
|
|
|
ASSERT_NTC(this->Valid());
|
|
this->VerifyLinkageFromThisDeque(m_Head);
|
|
|
|
// You should have cleaned up this deque beforehand...
|
|
ASSERT_NTC(m_EntryCount == 0);
|
|
|
|
m_EntryCount = 0;
|
|
|
|
ple.Restore();
|
|
}
|
|
|
|
VOID TakeValue(CDeque &rThat)
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
|
|
// Since we don't manage the storage of the entries, "this" deque
|
|
// must be empty.
|
|
ASSERT(m_EntryCount == 0);
|
|
|
|
// with regards to linkages, we only need to change the pseudo-head flink
|
|
// and blink, the actual head blink and the actual tail flink. However,
|
|
// for debugging purposes, we keep the identity of the deque that contains
|
|
// the linkage in the linkage, so we also have to fix those.
|
|
|
|
ASSERT(rThat.Valid());
|
|
|
|
CDequeLinkage *pLinkage = rThat.GetFlink(rThat.m_Head);
|
|
|
|
if (pLinkage != NULL)
|
|
{
|
|
while (pLinkage != &rThat.m_Head)
|
|
{
|
|
ASSERT(pLinkage->IsNotLocked());
|
|
this->SetDeque(pLinkage);
|
|
pLinkage = rThat.GetFlink(pLinkage);
|
|
}
|
|
}
|
|
|
|
// Now munge the pointers...
|
|
this->SetFlink(m_Head, rThat.GetFlink(rThat.m_Head));
|
|
this->SetBlink(m_Head, rThat.GetBlink(rThat.m_Head));
|
|
this->SetBlink(rThat.GetFlink(rThat.m_Head), &m_Head);
|
|
this->SetFlink(rThat.GetBlink(rThat.m_Head), &m_Head);
|
|
rThat.SetFlink(rThat.m_Head, &rThat.m_Head);
|
|
rThat.SetBlink(rThat.m_Head, &rThat.m_Head);
|
|
|
|
m_EntryCount = rThat.m_EntryCount;
|
|
rThat.m_EntryCount = 0;
|
|
}
|
|
|
|
VOID AddToHead(TEntry *pEntry)
|
|
{
|
|
FN_TRACE();
|
|
ASSERT(this->Valid());
|
|
this->InsertAfter(&m_Head, this->MapEntryToLinkage(pEntry), true);
|
|
}
|
|
|
|
VOID AddToTail(TEntry *pEntry)
|
|
{
|
|
FN_TRACE();
|
|
ASSERT(this->Valid());
|
|
this->InsertBefore(&m_Head, this->MapEntryToLinkage(pEntry), true);
|
|
}
|
|
|
|
VOID Add(TEntry *pEntry)
|
|
{
|
|
FN_TRACE();
|
|
ASSERT(this->Valid());
|
|
AddToTail(pEntry);
|
|
}
|
|
|
|
TEntry *RemoveHead()
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
|
|
TEntry *pEntry = NULL;
|
|
|
|
if (this->GetFlink(m_Head) != &m_Head)
|
|
{
|
|
CDequeLinkage *pLinkage = this->GetFlink(m_Head);
|
|
this->Remove(pLinkage, true);
|
|
pEntry = this->MapLinkageToEntry(pLinkage);
|
|
}
|
|
|
|
return pEntry;
|
|
}
|
|
|
|
TEntry *RemoveTail()
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
|
|
TEntry *pEntry = NULL;
|
|
|
|
if (this->GetBlink(m_Head) != &m_Head)
|
|
{
|
|
pEntry = this->GetBlink(m_Head);
|
|
this->Remove(pEntry, true);
|
|
}
|
|
|
|
return pEntry;
|
|
}
|
|
|
|
bool IsHead(CDequeLinkage *pLinkage) const { return pLinkage == &m_Head; }
|
|
|
|
VOID Remove(TEntry *pEntry)
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
|
|
this->Remove(this->MapEntryToLinkage(pEntry), true);
|
|
}
|
|
|
|
template <typename T> VOID ForEach(T *pt, VOID (T::*pmfn)(TEntry *p))
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
|
|
CDequeLinkage *pLinkage = this->GetFlink(m_Head);
|
|
|
|
if (pLinkage != NULL)
|
|
{
|
|
while (pLinkage != &m_Head)
|
|
{
|
|
// You can't remove the element that you're on during a ForEach() call.
|
|
pLinkage->Lock();
|
|
(pt->*pmfn)(this->MapLinkageToEntry(pLinkage));
|
|
pLinkage->Unlock();
|
|
pLinkage = this->GetFlink(pLinkage);
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename T> VOID ForEach(const T *pt, VOID (T::*pmfn)(TEntry *p) const)
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
CDequeLinkage *pLinkage = this->GetFlink(m_Head);
|
|
|
|
while ( pLinkage && (pLinkage != &m_Head) )
|
|
{
|
|
pLinkage->Lock();
|
|
(pt->*pmfn)(this->MapLinkageToEntry(pLinkage));
|
|
pLinkage->Unlock();
|
|
pLinkage = this->GetFlink(pLinkage);
|
|
}
|
|
}
|
|
|
|
template <typename T> VOID Clear(T *pt, VOID (T::*pmfn)(TEntry *p))
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
CDequeLinkage *pLinkage = this->GetFlink(m_Head);
|
|
|
|
if (pLinkage != NULL)
|
|
{
|
|
while (pLinkage != &m_Head)
|
|
{
|
|
CDequeLinkage *pLinkage_Next = this->GetFlink(pLinkage);
|
|
ASSERT(pLinkage->IsNotLocked());
|
|
(pt->*pmfn)(this->MapLinkageToEntry(pLinkage));
|
|
pLinkage = pLinkage_Next;
|
|
}
|
|
}
|
|
|
|
this->ResetHead();
|
|
m_EntryCount = 0;
|
|
}
|
|
|
|
template <typename T> VOID Clear(const T *pt, VOID (T::*pmfn)(TEntry *p) const)
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
CDequeLinkage *pLinkage = this->GetFlink(m_Head);
|
|
|
|
if (pLinkage != NULL)
|
|
{
|
|
while (pLinkage != &m_Head)
|
|
{
|
|
CDequeLinkage *pLinkage_Next = this->GetFlink(pLinkage);
|
|
ASSERT(pLinkage->IsNotLocked());
|
|
(pt->*pmfn)(this->MapLinkageToEntry(pLinkage));
|
|
pLinkage = pLinkage_Next;
|
|
}
|
|
}
|
|
|
|
this->ResetHead();
|
|
m_EntryCount = 0;
|
|
}
|
|
|
|
VOID Clear(VOID (TEntry::*pmfn)())
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
CDequeLinkage *pLinkage = this->GetFlink(m_Head);
|
|
|
|
if (pLinkage != NULL)
|
|
{
|
|
while (pLinkage != &m_Head)
|
|
{
|
|
CDequeLinkage *pLinkage_Next = this->GetFlink(pLinkage);
|
|
ASSERT(pLinkage->IsNotLocked());
|
|
TEntry* pEntry = this->MapLinkageToEntry(pLinkage);
|
|
(pEntry->*pmfn)();
|
|
pLinkage = pLinkage_Next;
|
|
}
|
|
}
|
|
|
|
this->ResetHead();
|
|
m_EntryCount = 0;
|
|
}
|
|
|
|
VOID ClearAndDeleteAll()
|
|
{
|
|
FN_TRACE();
|
|
ASSERT(this->Valid());
|
|
CDequeLinkage *pLinkage = this->GetFlink(m_Head);
|
|
|
|
if (pLinkage != NULL)
|
|
{
|
|
while (pLinkage != &m_Head)
|
|
{
|
|
CDequeLinkage *pLinkage_Next = this->GetFlink(pLinkage);
|
|
ASSERT(pLinkage->IsNotLocked());
|
|
TEntry* pEntry = this->MapLinkageToEntry(pLinkage);
|
|
FUSION_DELETE_SINGLETON(pEntry);
|
|
pLinkage = pLinkage_Next;
|
|
}
|
|
}
|
|
|
|
this->ResetHead();
|
|
m_EntryCount = 0;
|
|
}
|
|
|
|
void ClearNoCallback()
|
|
{
|
|
FN_TRACE();
|
|
|
|
ASSERT(this->Valid());
|
|
|
|
this->ResetHead();
|
|
m_EntryCount = 0;
|
|
}
|
|
|
|
|
|
SIZE_T GetEntryCount() const { return m_EntryCount; }
|
|
bool IsEmpty() const { return m_EntryCount == 0; }
|
|
|
|
protected:
|
|
using CDequeBase::Remove;
|
|
|
|
TEntry *MapLinkageToEntry(CDequeLinkage *pLinkage) const
|
|
{
|
|
ASSERT_NTC(pLinkage != &m_Head);
|
|
|
|
if (pLinkage == &m_Head)
|
|
return NULL;
|
|
|
|
return (TEntry *) (((LONG_PTR) pLinkage) - LinkageMemberOffset);
|
|
}
|
|
|
|
CDequeLinkage *MapEntryToLinkage(TEntry *pEntry) const
|
|
{
|
|
ASSERT_NTC(pEntry != NULL);
|
|
|
|
return (CDequeLinkage *) (((LONG_PTR) pEntry) + LinkageMemberOffset);
|
|
}
|
|
|
|
private:
|
|
CDeque(const CDeque &r); // intentionally not implemented
|
|
void operator =(const CDeque &r); // intentionally not implemented
|
|
};
|
|
|
|
enum DequeIteratorMovementDirection
|
|
{
|
|
eDequeIteratorMoveForward,
|
|
eDequeIteratorMoveBackward
|
|
};
|
|
|
|
template <typename TEntry, size_t LinkageMemberOffset> class CConstDequeIterator
|
|
{
|
|
public:
|
|
CConstDequeIterator(const CDeque<TEntry, LinkageMemberOffset> *Deque = NULL) : m_Deque(Deque), m_pCurrent(NULL) { }
|
|
|
|
~CConstDequeIterator()
|
|
{
|
|
if (m_pCurrent != NULL)
|
|
{
|
|
m_pCurrent->Unlock();
|
|
m_pCurrent = NULL;
|
|
}
|
|
}
|
|
|
|
VOID Rebind(const CDeque<TEntry, LinkageMemberOffset> *NewDeque)
|
|
{
|
|
FN_TRACE();
|
|
|
|
if (m_pCurrent != NULL)
|
|
{
|
|
m_pCurrent->Unlock();
|
|
m_pCurrent = NULL;
|
|
}
|
|
|
|
m_Deque = NewDeque;
|
|
if (NewDeque != NULL)
|
|
{
|
|
m_pCurrent = this->GetFirstLinkage();
|
|
m_pCurrent->Lock();
|
|
}
|
|
}
|
|
|
|
bool IsBound() const { return (m_Deque != NULL); }
|
|
|
|
VOID Unbind()
|
|
{
|
|
FN_TRACE();
|
|
|
|
if (m_Deque != NULL)
|
|
{
|
|
if (m_pCurrent != NULL)
|
|
{
|
|
m_pCurrent->Unlock();
|
|
m_pCurrent = NULL;
|
|
}
|
|
|
|
m_Deque = NULL;
|
|
}
|
|
}
|
|
|
|
// You can't remove an element that the iterator is sitting on; usually you just
|
|
// save the current element and move to the next one, but if you found the exact
|
|
// element you wanted and don't want to use the iterator any more, you can Close()
|
|
// it to release the lock.
|
|
VOID Close()
|
|
{
|
|
FN_TRACE();
|
|
|
|
if (m_pCurrent != NULL)
|
|
{
|
|
m_pCurrent->Unlock();
|
|
m_pCurrent = NULL;
|
|
}
|
|
}
|
|
|
|
inline VOID Reset()
|
|
{
|
|
if (m_pCurrent != NULL)
|
|
{
|
|
m_pCurrent->Unlock();
|
|
m_pCurrent = NULL;
|
|
}
|
|
|
|
m_pCurrent = this->GetFirstLinkage();
|
|
m_pCurrent->Lock();
|
|
}
|
|
|
|
inline VOID Move(DequeIteratorMovementDirection eDirection)
|
|
{
|
|
ASSERT_NTC(m_pCurrent != NULL);
|
|
ASSERT_NTC((eDirection == eDequeIteratorMoveForward) ||
|
|
(eDirection == eDequeIteratorMoveBackward));
|
|
|
|
m_pCurrent->Unlock();
|
|
if (eDirection == eDequeIteratorMoveForward)
|
|
m_pCurrent = m_Deque->GetFlink(m_pCurrent);
|
|
else if (eDirection == eDequeIteratorMoveBackward)
|
|
m_pCurrent = m_Deque->GetBlink(m_pCurrent);
|
|
m_pCurrent->Lock();
|
|
}
|
|
|
|
VOID Next() { this->Move(eDequeIteratorMoveForward); }
|
|
VOID Previous() { this->Move(eDequeIteratorMoveBackward); }
|
|
|
|
bool More() const { return (m_pCurrent != NULL) && (m_pCurrent != &m_Deque->m_Head); }
|
|
|
|
TEntry *operator ->() const { ASSERT_NTC(m_pCurrent != NULL); return this->MapLinkageToEntry(m_pCurrent); }
|
|
operator TEntry *() const { ASSERT_NTC(m_pCurrent != NULL); return this->MapLinkageToEntry(m_pCurrent); }
|
|
TEntry *Current() const { ASSERT_NTC(m_pCurrent != NULL); return this->MapLinkageToEntry(m_pCurrent); }
|
|
|
|
protected:
|
|
CDequeLinkage *GetFirstLinkage() const { return m_Deque->GetFlink(m_Deque->m_Head); }
|
|
CDequeLinkage *GetLastLinkage() const { return m_Deque->GetBlink(m_Deque->m_Head); }
|
|
|
|
TEntry *MapLinkageToEntry(CDequeLinkage *pLinkage) const { return m_Deque->MapLinkageToEntry(pLinkage); }
|
|
|
|
const CDeque<TEntry, LinkageMemberOffset> *m_Deque;
|
|
CDequeLinkage *m_pCurrent;
|
|
};
|
|
|
|
template <typename TEntry, size_t LinkageMemberOffset> class CDequeIterator : public CConstDequeIterator<TEntry, LinkageMemberOffset>
|
|
{
|
|
typedef CConstDequeIterator<TEntry, LinkageMemberOffset> Base;
|
|
|
|
public:
|
|
CDequeIterator(CDeque<TEntry, LinkageMemberOffset> *Deque = NULL) : Base(Deque) { }
|
|
|
|
~CDequeIterator() { }
|
|
|
|
VOID Rebind(CDeque<TEntry, LinkageMemberOffset> *NewDeque)
|
|
{
|
|
FN_TRACE();
|
|
|
|
if (m_pCurrent != NULL)
|
|
{
|
|
m_pCurrent->Unlock();
|
|
m_pCurrent = NULL;
|
|
}
|
|
|
|
m_Deque = NewDeque;
|
|
|
|
if (NewDeque != NULL)
|
|
{
|
|
m_pCurrent = this->GetFirstLinkage();
|
|
m_pCurrent->Lock();
|
|
}
|
|
}
|
|
|
|
TEntry *RemoveCurrent(DequeIteratorMovementDirection eDirection)
|
|
{
|
|
FN_TRACE();
|
|
TEntry *Result = NULL;
|
|
|
|
ASSERT(m_pCurrent != NULL);
|
|
ASSERT(!m_Deque->IsHead(m_pCurrent));
|
|
|
|
if ((m_pCurrent != NULL) && (!m_Deque->IsHead(m_pCurrent)))
|
|
{
|
|
Result = this->MapLinkageToEntry(m_pCurrent);
|
|
this->Move(eDirection);
|
|
const_cast<CDeque<TEntry, LinkageMemberOffset> *>(m_Deque)->Remove(Result);
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
void DeleteCurrent(DequeIteratorMovementDirection eDirection)
|
|
{
|
|
FN_TRACE();
|
|
TEntry *Result = this->RemoveCurrent(eDirection);
|
|
|
|
if (Result != NULL)
|
|
FUSION_DELETE_SINGLETON(Result);
|
|
}
|
|
|
|
protected:
|
|
// All member data is in the parent...
|
|
};
|
|
|
|
#ifdef FN_TRACE_SHOULD_POP
|
|
#pragma pop_macro("FN_TRACE")
|
|
#undef FN_TRACE_SHOULD_POP
|
|
#elif defined(FN_TRACE_SHOULD_DESTROY)
|
|
#undef FN_TRACE
|
|
#endif
|
|
|
|
#ifdef FN_TRACE_CONSTRUCTOR_SHOULD_POP
|
|
#pragma pop_macro("FN_TRACE_CONSTRUCTOR")
|
|
#undef FN_TRACE_CONSTRUCTOR_SHOULD_POP
|
|
#elif defined(FN_TRACE_CONSTRUCTOR_SHOULD_DESTROY)
|
|
#undef FN_TRACE_CONSTRUCTOR
|
|
#endif
|
|
|
|
#ifdef FN_TRACE_DESTRUCTOR_SHOULD_POP
|
|
#pragma pop_macro("FN_TRACE_DESTRUCTOR")
|
|
#undef FN_TRACE_DESTRUCTOR_SHOULD_POP
|
|
#elif defined(FN_TRACE_DESTRUCTOR_SHOULD_DESTROY)
|
|
#undef FN_TRACE_DESTRUCTOR
|
|
#endif
|
|
|