source-engine/public/tier1/utlntree.h

625 lines
15 KiB
C
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= 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