mirror of
https://github.com/alliedmodders/hl2sdk.git
synced 2024-12-23 01:59:43 +08:00
625 lines
16 KiB
C++
625 lines
16 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: N-way tree container class
|
|
//
|
|
// $Revision: $
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef UTLNTREE_H
|
|
#define UTLNTREE_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "basetypes.h"
|
|
#include "utlmemory.h"
|
|
#include "tier0/dbg.h"
|
|
|
|
|
|
#define INVALID_NTREE_IDX ((I)~0)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// class CUtlNTree:
|
|
// description:
|
|
// A lovely index-based linked list! T is the class type, I is the index
|
|
// type, which usually should be an unsigned short or smaller.
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I = unsigned short>
|
|
class CUtlNTree
|
|
{
|
|
public:
|
|
typedef T ElemType_t;
|
|
typedef I IndexType_t;
|
|
|
|
// constructor, destructor
|
|
CUtlNTree( int growSize = 0, int initSize = 0 );
|
|
CUtlNTree( void *pMemory, int memsize );
|
|
~CUtlNTree( );
|
|
|
|
// gets particular elements
|
|
T& Element( I i );
|
|
const T& Element( I i ) const;
|
|
T& operator[]( I i );
|
|
const T& operator[]( I i ) const;
|
|
|
|
// Make sure we have a particular amount of memory
|
|
void EnsureCapacity( int num );
|
|
|
|
// Clears the tree, doesn't deallocate memory
|
|
void RemoveAll();
|
|
|
|
// Memory deallocation
|
|
void Purge();
|
|
|
|
// Allocation/deallocation methods
|
|
I Alloc( );
|
|
void Free( I elem );
|
|
void FreeSubTree( I elem );
|
|
|
|
// list modification
|
|
void SetRoot( I root );
|
|
void LinkChildBefore( I parent, I before, I elem );
|
|
void LinkChildAfter( I parent, I after, I elem );
|
|
void Unlink( I elem );
|
|
|
|
// Alloc + link combined
|
|
I InsertChildBefore( I parent, I before );
|
|
I InsertChildAfter( I parent, I after );
|
|
I InsertChildBefore( I parent, I before, const T &elem );
|
|
I InsertChildAfter( I parent, I after, const T &elem );
|
|
|
|
// Unlink + free combined
|
|
void Remove( I elem );
|
|
void RemoveSubTree( I elem );
|
|
|
|
// invalid index
|
|
inline static I InvalidIndex() { return INVALID_NTREE_IDX; }
|
|
inline static size_t ElementSize() { return sizeof(Node_t); }
|
|
|
|
// list statistics
|
|
int Count() const;
|
|
I MaxElementIndex() const;
|
|
|
|
// Traversing the list
|
|
I Root() const;
|
|
I FirstChild( I i ) const;
|
|
I PrevSibling( I i ) const;
|
|
I NextSibling( I i ) const;
|
|
I Parent( I i ) const;
|
|
|
|
// Are nodes in the list or valid?
|
|
bool IsValidIndex( I i ) const;
|
|
bool IsInTree( I i ) const;
|
|
|
|
protected:
|
|
// What the linked list element looks like
|
|
struct Node_t
|
|
{
|
|
T m_Element;
|
|
I m_Parent;
|
|
I m_FirstChild;
|
|
I m_PrevSibling;
|
|
I m_NextSibling;
|
|
|
|
private:
|
|
// No copy constructor for these...
|
|
Node_t( const Node_t& );
|
|
};
|
|
|
|
// constructs the class
|
|
void ConstructList();
|
|
|
|
// Allocates the element, doesn't call the constructor
|
|
I AllocInternal();
|
|
|
|
// Gets at the node element....
|
|
Node_t& InternalNode( I i ) { return m_Memory[i]; }
|
|
const Node_t& InternalNode( I i ) const { return m_Memory[i]; }
|
|
|
|
void ResetDbgInfo()
|
|
{
|
|
m_pElements = m_Memory.Base();
|
|
}
|
|
|
|
// copy constructors not allowed
|
|
CUtlNTree( CUtlNTree<T, I> const& tree ) { Assert(0); }
|
|
|
|
CUtlMemory<Node_t> m_Memory;
|
|
I m_Root;
|
|
I m_FirstFree;
|
|
I m_ElementCount; // The number actually in the tree
|
|
I m_MaxElementIndex; // The max index we've ever assigned
|
|
|
|
// For debugging purposes;
|
|
// it's in release builds so this can be used in libraries correctly
|
|
Node_t *m_pElements;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T, class I>
|
|
CUtlNTree<T,I>::CUtlNTree( int growSize, int initSize ) :
|
|
m_Memory(growSize, initSize)
|
|
{
|
|
ConstructList();
|
|
ResetDbgInfo();
|
|
}
|
|
|
|
template <class T, class I>
|
|
CUtlNTree<T,I>::CUtlNTree( void* pMemory, int memsize ) :
|
|
m_Memory(pMemory, memsize/sizeof(T))
|
|
{
|
|
ConstructList();
|
|
ResetDbgInfo();
|
|
}
|
|
|
|
template <class T, class I>
|
|
CUtlNTree<T,I>::~CUtlNTree( )
|
|
{
|
|
RemoveAll();
|
|
}
|
|
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::ConstructList()
|
|
{
|
|
m_Root = InvalidIndex();
|
|
m_FirstFree = InvalidIndex();
|
|
m_ElementCount = m_MaxElementIndex = 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// gets particular elements
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
inline T& CUtlNTree<T,I>::Element( I i )
|
|
{
|
|
return m_Memory[i].m_Element;
|
|
}
|
|
|
|
template <class T, class I>
|
|
inline const T& CUtlNTree<T,I>::Element( I i ) const
|
|
{
|
|
return m_Memory[i].m_Element;
|
|
}
|
|
|
|
template <class T, class I>
|
|
inline T& CUtlNTree<T,I>::operator[]( I i )
|
|
{
|
|
return m_Memory[i].m_Element;
|
|
}
|
|
|
|
template <class T, class I>
|
|
inline const T& CUtlNTree<T,I>::operator[]( I i ) const
|
|
{
|
|
return m_Memory[i].m_Element;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// list statistics
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
inline int CUtlNTree<T,I>::Count() const
|
|
{
|
|
return m_ElementCount;
|
|
}
|
|
|
|
template <class T, class I>
|
|
inline I CUtlNTree<T,I>::MaxElementIndex() const
|
|
{
|
|
return m_MaxElementIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Traversing the list
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
inline I CUtlNTree<T,I>::Root() const
|
|
{
|
|
return m_Root;
|
|
}
|
|
|
|
template <class T, class I>
|
|
inline I CUtlNTree<T,I>::FirstChild( I i ) const
|
|
{
|
|
Assert( IsInTree(i) );
|
|
return InternalNode(i).m_FirstChild;
|
|
}
|
|
|
|
template <class T, class I>
|
|
inline I CUtlNTree<T,I>::PrevSibling( I i ) const
|
|
{
|
|
Assert( IsInTree(i) );
|
|
return InternalNode(i).m_PrevSibling;
|
|
}
|
|
|
|
template <class T, class I>
|
|
inline I CUtlNTree<T,I>::NextSibling( I i ) const
|
|
{
|
|
Assert( IsInTree(i) );
|
|
return InternalNode(i).m_NextSibling;
|
|
}
|
|
|
|
template <class T, class I>
|
|
inline I CUtlNTree<T,I>::Parent( I i ) const
|
|
{
|
|
Assert( IsInTree(i) );
|
|
return InternalNode(i).m_Parent;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Are nodes in the list or valid?
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
inline bool CUtlNTree<T,I>::IsValidIndex( I i ) const
|
|
{
|
|
return (i < m_MaxElementIndex) && (i >= 0);
|
|
}
|
|
|
|
template <class T, class I>
|
|
inline bool CUtlNTree<T,I>::IsInTree( I i ) const
|
|
{
|
|
return (i < m_MaxElementIndex) && (i >= 0) && (InternalNode(i).m_PrevSibling != i);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Makes sure we have enough memory allocated to store a requested # of elements
|
|
//-----------------------------------------------------------------------------
|
|
template< class T, class I >
|
|
void CUtlNTree<T, I>::EnsureCapacity( int num )
|
|
{
|
|
MEM_ALLOC_CREDIT_CLASS();
|
|
m_Memory.EnsureCapacity(num);
|
|
ResetDbgInfo();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Deallocate memory
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::Purge()
|
|
{
|
|
RemoveAll();
|
|
m_Memory.Purge( );
|
|
m_FirstFree = InvalidIndex();
|
|
m_MaxElementIndex = 0;
|
|
ResetDbgInfo();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Node allocation/deallocation
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
I CUtlNTree<T,I>::AllocInternal( )
|
|
{
|
|
I elem;
|
|
if ( m_FirstFree == INVALID_NTREE_IDX )
|
|
{
|
|
// Nothing in the free list; add.
|
|
// Since nothing is in the free list, m_MaxElementIndex == total # of elements
|
|
// the list knows about.
|
|
if ((int)m_MaxElementIndex == m_Memory.NumAllocated())
|
|
{
|
|
MEM_ALLOC_CREDIT_CLASS();
|
|
m_Memory.Grow();
|
|
}
|
|
|
|
Assert( m_MaxElementIndex != INVALID_NTREE_IDX );
|
|
|
|
elem = (I)m_MaxElementIndex;
|
|
++m_MaxElementIndex;
|
|
|
|
if ( elem == InvalidIndex() )
|
|
{
|
|
Error("CUtlNTree overflow!\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
elem = m_FirstFree;
|
|
m_FirstFree = InternalNode( m_FirstFree ).m_NextSibling;
|
|
}
|
|
|
|
Node_t &node = InternalNode( elem );
|
|
node.m_NextSibling = node.m_PrevSibling = node.m_Parent = node.m_FirstChild = INVALID_NTREE_IDX;
|
|
ResetDbgInfo();
|
|
|
|
// one more element baby
|
|
++m_ElementCount;
|
|
|
|
return elem;
|
|
}
|
|
|
|
template <class T, class I>
|
|
I CUtlNTree<T,I>::Alloc( )
|
|
{
|
|
I elem = AllocInternal();
|
|
Construct( &Element(elem) );
|
|
return elem;
|
|
}
|
|
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::Free( I elem )
|
|
{
|
|
Assert( IsInTree( elem ) );
|
|
Unlink( elem );
|
|
|
|
// If there's children, this will result in leaks. Use FreeSubTree instead.
|
|
Assert( FirstChild( elem ) == INVALID_NTREE_IDX );
|
|
|
|
Node_t &node = InternalNode( elem );
|
|
Destruct( &node.m_Element );
|
|
node.m_NextSibling = m_FirstFree;
|
|
node.m_PrevSibling = elem; // Marks it as being in the free list
|
|
node.m_Parent = node.m_FirstChild = INVALID_NTREE_IDX;
|
|
m_FirstFree = elem;
|
|
|
|
// one less element baby
|
|
--m_ElementCount;
|
|
}
|
|
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::FreeSubTree( I elem )
|
|
{
|
|
Assert( IsValidIndex( elem ) );
|
|
|
|
I child = FirstChild( elem );
|
|
while ( child != INVALID_NTREE_IDX )
|
|
{
|
|
I next = NextSibling( child );
|
|
FreeSubTree( child );
|
|
child = next;
|
|
}
|
|
|
|
Free( elem );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Clears the tree
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::RemoveAll()
|
|
{
|
|
if ( m_MaxElementIndex == 0 )
|
|
return;
|
|
|
|
// Put everything into the free list (even unlinked things )
|
|
I prev = InvalidIndex();
|
|
for (int i = (int)m_MaxElementIndex; --i >= 0; prev = (I)i )
|
|
{
|
|
Node_t &node = InternalNode( i );
|
|
if ( IsInTree( i ) )
|
|
{
|
|
Destruct( &node.m_Element );
|
|
}
|
|
|
|
node.m_NextSibling = prev;
|
|
node.m_PrevSibling = (I)i; // Marks it as being in the free list
|
|
node.m_Parent = node.m_FirstChild = INVALID_NTREE_IDX;
|
|
}
|
|
|
|
// First free points to the first element
|
|
m_FirstFree = 0;
|
|
|
|
// Clear everything else out
|
|
m_Root = INVALID_NTREE_IDX;
|
|
m_ElementCount = 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// list modification
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::SetRoot( I root )
|
|
{
|
|
// Resetting the root while it's got stuff in it is bad...
|
|
Assert( m_Root == InvalidIndex() );
|
|
m_Root = root;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Links a node after a particular node
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::LinkChildAfter( I parent, I after, I elem )
|
|
{
|
|
Assert( IsInTree(elem) );
|
|
|
|
// Unlink it if it's in the list at the moment
|
|
Unlink(elem);
|
|
|
|
Node_t& newElem = InternalNode(elem);
|
|
newElem.m_Parent = parent;
|
|
newElem.m_PrevSibling = after;
|
|
if ( after != INVALID_NTREE_IDX )
|
|
{
|
|
Node_t& prevSiblingNode = InternalNode( after );
|
|
newElem.m_NextSibling = prevSiblingNode.m_NextSibling;
|
|
prevSiblingNode.m_NextSibling = elem;
|
|
}
|
|
else
|
|
{
|
|
if ( parent != INVALID_NTREE_IDX )
|
|
{
|
|
Node_t& parentNode = InternalNode( parent );
|
|
newElem.m_NextSibling = parentNode.m_FirstChild;
|
|
parentNode.m_FirstChild = elem;
|
|
}
|
|
else
|
|
{
|
|
newElem.m_NextSibling = m_Root;
|
|
if ( m_Root != INVALID_NTREE_IDX )
|
|
{
|
|
Node_t& rootNode = InternalNode( m_Root );
|
|
rootNode.m_PrevSibling = elem;
|
|
}
|
|
m_Root = elem;
|
|
}
|
|
}
|
|
|
|
if ( newElem.m_NextSibling != INVALID_NTREE_IDX )
|
|
{
|
|
Node_t& nextSiblingNode = InternalNode( newElem.m_NextSibling );
|
|
nextSiblingNode.m_PrevSibling = elem;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Links a node before a particular node
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::LinkChildBefore( I parent, I before, I elem )
|
|
{
|
|
Assert( IsValidIndex(elem) );
|
|
|
|
if ( before != INVALID_NTREE_IDX )
|
|
{
|
|
LinkChildAfter( parent, InternalNode( before ).m_PrevSibling, elem );
|
|
return;
|
|
}
|
|
|
|
// NOTE: I made the choice to do an O(n) operation here
|
|
// instead of store more data per node (LastChild).
|
|
// This might not be the right choice. Revisit if we get perf problems.
|
|
I after;
|
|
if ( parent != INVALID_NTREE_IDX )
|
|
{
|
|
after = InternalNode( parent ).m_FirstChild;
|
|
}
|
|
else
|
|
{
|
|
after = m_Root;
|
|
}
|
|
|
|
if ( after == INVALID_NTREE_IDX )
|
|
{
|
|
LinkChildAfter( parent, after, elem );
|
|
return;
|
|
}
|
|
|
|
I next = InternalNode( after ).m_NextSibling;
|
|
while ( next != InvalidIndex() )
|
|
{
|
|
after = next;
|
|
next = InternalNode( next ).m_NextSibling;
|
|
}
|
|
|
|
LinkChildAfter( parent, after, elem );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Unlinks a node from the tree
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::Unlink( I elem )
|
|
{
|
|
Assert( IsInTree(elem) );
|
|
|
|
Node_t *pOldNode = &InternalNode( elem );
|
|
|
|
// If we're the first guy, reset the head
|
|
// otherwise, make our previous node's next pointer = our next
|
|
if ( pOldNode->m_PrevSibling != INVALID_NTREE_IDX )
|
|
{
|
|
InternalNode( pOldNode->m_PrevSibling ).m_NextSibling = pOldNode->m_NextSibling;
|
|
}
|
|
else
|
|
{
|
|
if ( pOldNode->m_Parent != INVALID_NTREE_IDX )
|
|
{
|
|
InternalNode( pOldNode->m_Parent ).m_FirstChild = pOldNode->m_NextSibling;
|
|
}
|
|
else if ( m_Root == elem )
|
|
{
|
|
m_Root = pOldNode->m_NextSibling;
|
|
}
|
|
}
|
|
|
|
// If we're the last guy, reset the tail
|
|
// otherwise, make our next node's prev pointer = our prev
|
|
if ( pOldNode->m_NextSibling != INVALID_NTREE_IDX )
|
|
{
|
|
InternalNode( pOldNode->m_NextSibling ).m_PrevSibling = pOldNode->m_PrevSibling;
|
|
}
|
|
|
|
// Unlink everything except children
|
|
pOldNode->m_Parent = pOldNode->m_PrevSibling = pOldNode->m_NextSibling = INVALID_NTREE_IDX;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Alloc + link combined
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
I CUtlNTree<T,I>::InsertChildBefore( I parent, I before )
|
|
{
|
|
I elem = AllocInternal();
|
|
Construct( &Element( elem ) );
|
|
LinkChildBefore( parent, before, elem );
|
|
return elem;
|
|
}
|
|
|
|
template <class T, class I>
|
|
I CUtlNTree<T,I>::InsertChildAfter( I parent, I after )
|
|
{
|
|
I elem = AllocInternal();
|
|
Construct( &Element( elem ) );
|
|
LinkChildAfter( parent, after, elem );
|
|
return elem;
|
|
}
|
|
|
|
template <class T, class I>
|
|
I CUtlNTree<T,I>::InsertChildBefore( I parent, I before, const T &data )
|
|
{
|
|
I elem = AllocInternal();
|
|
CopyConstruct( &Element( elem ), data );
|
|
LinkChildBefore( parent, before, elem );
|
|
return elem;
|
|
}
|
|
|
|
template <class T, class I>
|
|
I CUtlNTree<T,I>::InsertChildAfter( I parent, I after, const T &data )
|
|
{
|
|
I elem = AllocInternal();
|
|
CopyConstruct( &Element( elem ), data );
|
|
LinkChildAfter( parent, after, elem );
|
|
return elem;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Unlink + free combined
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::Remove( I elem )
|
|
{
|
|
Unlink( elem );
|
|
Free( elem );
|
|
}
|
|
|
|
template <class T, class I>
|
|
void CUtlNTree<T,I>::RemoveSubTree( I elem )
|
|
{
|
|
UnlinkSubTree( elem );
|
|
Free( elem );
|
|
}
|
|
|
|
|
|
#endif // UTLNTREE_H
|