1421 lines
40 KiB
C++
1421 lines
40 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "datamodel/dmelement.h"
|
|
#include "tier0/dbg.h"
|
|
#include "datamodel.h"
|
|
#include "tier1/utllinkedlist.h"
|
|
#include "tier1/utlbuffer.h"
|
|
#include "datamodel/dmattribute.h"
|
|
#include "Color.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include "mathlib/vmatrix.h"
|
|
#include "datamodel/dmelementfactoryhelper.h"
|
|
#include "datamodel/dmattributevar.h"
|
|
#include "dmattributeinternal.h"
|
|
#include "DmElementFramework.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// helper class to allow CDmeHandle access to g_pDataModelImp
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeElementRefHelper::Ref( DmElementHandle_t hElement, bool bStrong )
|
|
{
|
|
g_pDataModelImp->OnElementReferenceAdded( hElement, bStrong );
|
|
}
|
|
|
|
void CDmeElementRefHelper::Unref( DmElementHandle_t hElement, bool bStrong )
|
|
{
|
|
g_pDataModelImp->OnElementReferenceRemoved( hElement, bStrong );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// element reference struct - containing attribute referrers and handle refcount
|
|
//-----------------------------------------------------------------------------
|
|
void DmElementReference_t::AddAttribute( CDmAttribute *pAttribute )
|
|
{
|
|
if ( m_attributes.m_hAttribute != DMATTRIBUTE_HANDLE_INVALID )
|
|
{
|
|
DmAttributeList_t *pLink = new DmAttributeList_t; // TODO - create a fixed size allocator for these
|
|
pLink->m_hAttribute = m_attributes.m_hAttribute;
|
|
pLink->m_pNext = m_attributes.m_pNext;
|
|
m_attributes.m_pNext = pLink;
|
|
}
|
|
m_attributes.m_hAttribute = pAttribute->GetHandle();
|
|
}
|
|
|
|
void DmElementReference_t::RemoveAttribute( CDmAttribute *pAttribute )
|
|
{
|
|
DmAttributeHandle_t hAttribute = pAttribute->GetHandle();
|
|
if ( m_attributes.m_hAttribute == hAttribute )
|
|
{
|
|
DmAttributeList_t *pNext = m_attributes.m_pNext;
|
|
if ( pNext )
|
|
{
|
|
m_attributes.m_hAttribute = pNext->m_hAttribute;
|
|
m_attributes.m_pNext = pNext->m_pNext;
|
|
delete pNext;
|
|
}
|
|
else
|
|
{
|
|
m_attributes.m_hAttribute = DMATTRIBUTE_HANDLE_INVALID;
|
|
}
|
|
return;
|
|
}
|
|
|
|
for ( DmAttributeList_t *pLink = &m_attributes; pLink->m_pNext; pLink = pLink->m_pNext )
|
|
{
|
|
DmAttributeList_t *pNext = pLink->m_pNext;
|
|
if ( pNext->m_hAttribute == hAttribute )
|
|
{
|
|
pLink->m_pNext = pNext->m_pNext;
|
|
delete pNext; // TODO - create a fixed size allocator for these
|
|
return;
|
|
}
|
|
}
|
|
|
|
Assert( 0 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Class factory
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_ELEMENT_FACTORY( DmElement, CDmElement );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// For backward compat: DmeElement -> creates a CDmElement class
|
|
//-----------------------------------------------------------------------------
|
|
CDmElementFactory< CDmElement > g_CDmeElement_Factory( "DmeElement" );
|
|
CDmElementFactoryHelper g_CDmeElement_Helper( "DmeElement", &g_CDmeElement_Factory, true );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
CDmElement::CDmElement( DmElementHandle_t handle, const char *pElementType, const DmObjectId_t &id, const char *pElementName, DmFileId_t fileid ) :
|
|
m_ref( handle ), m_Type( g_pDataModel->GetSymbol( pElementType ) ), m_fileId( fileid ),
|
|
m_pAttributes( NULL ), m_bDirty( false ), m_bBeingUnserialized( false ), m_bIsAcessible( true )
|
|
{
|
|
MEM_ALLOC_CREDIT();
|
|
g_pDataModelImp->AddElementToFile( m_ref.m_hElement, m_fileId );
|
|
m_Name.InitAndSet( this, "name", pElementName, FATTRIB_TOPOLOGICAL | FATTRIB_STANDARD );
|
|
CopyUniqueId( id, &m_Id );
|
|
}
|
|
|
|
CDmElement::~CDmElement()
|
|
{
|
|
g_pDataModelImp->RemoveElementFromFile( m_ref.m_hElement, m_fileId );
|
|
}
|
|
|
|
void CDmElement::PerformConstruction()
|
|
{
|
|
OnConstruction();
|
|
}
|
|
|
|
void CDmElement::PerformDestruction()
|
|
{
|
|
OnDestruction();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Deletes all attributes
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::Purge()
|
|
{
|
|
// Don't create "undo" records for attribute changes here, since
|
|
// the entire element is getting deleted...
|
|
CDisableUndoScopeGuard guard;
|
|
|
|
while ( m_pAttributes )
|
|
{
|
|
#if defined( _DEBUG )
|
|
// So you can see what attribute is being destroyed
|
|
const char *pName = m_pAttributes->GetName();
|
|
NOTE_UNUSED( pName );
|
|
#endif
|
|
CDmAttribute *pNext = m_pAttributes->NextAttribute();
|
|
CDmAttribute::DestroyAttribute( m_pAttributes );
|
|
m_pAttributes = pNext;
|
|
}
|
|
|
|
g_pDataModelImp->NotifyState( NOTIFY_CHANGE_TOPOLOGICAL );
|
|
}
|
|
|
|
|
|
void CDmElement::SetId( const DmObjectId_t &id )
|
|
{
|
|
CopyUniqueId( id, &m_Id );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// RTTI implementation
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::SetTypeSymbol( CUtlSymbol sym )
|
|
{
|
|
m_classType = sym;
|
|
}
|
|
|
|
bool CDmElement::IsA( UtlSymId_t typeSymbol ) const
|
|
{
|
|
// NOTE: This pattern here is used to avoid a zillion virtual function
|
|
// calls in the implementation of IsA. The IsA_Implementation is
|
|
// all static function calls.
|
|
return IsA_Implementation( typeSymbol );
|
|
}
|
|
|
|
int CDmElement::GetInheritanceDepth( UtlSymId_t typeSymbol ) const
|
|
{
|
|
// NOTE: This pattern here is used to avoid a zillion virtual function
|
|
// calls in the implementation of IsA. The IsA_Implementation is
|
|
// all static function calls.
|
|
return GetInheritanceDepth_Implementation( typeSymbol, 0 );
|
|
}
|
|
|
|
// Helper for GetInheritanceDepth
|
|
int CDmElement::GetInheritanceDepth( const char *pTypeName ) const
|
|
{
|
|
CUtlSymbol typeSymbol = g_pDataModel->GetSymbol( pTypeName );
|
|
return GetInheritanceDepth( typeSymbol );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is the element dirty?
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmElement::IsDirty() const
|
|
{
|
|
return m_bDirty;
|
|
}
|
|
|
|
void CDmElement::MarkDirty( bool bDirty )
|
|
{
|
|
if ( bDirty && !m_bDirty )
|
|
{
|
|
g_pDmElementFrameworkImp->AddElementToDirtyList( m_ref.m_hElement );
|
|
}
|
|
m_bDirty = bDirty;
|
|
}
|
|
|
|
void CDmElement::MarkAttributesClean()
|
|
{
|
|
for ( CDmAttribute *pAttr = m_pAttributes; pAttr; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
// No Undo for flag changes
|
|
pAttr->RemoveFlag( FATTRIB_DIRTY );
|
|
}
|
|
}
|
|
|
|
void CDmElement::MarkBeingUnserialized( bool beingUnserialized )
|
|
{
|
|
if ( m_bBeingUnserialized != beingUnserialized )
|
|
{
|
|
m_bBeingUnserialized = beingUnserialized;
|
|
|
|
// After we finish unserialization, call OnAttributeChanged; assume everything changed
|
|
if ( !beingUnserialized )
|
|
{
|
|
for( CDmAttribute *pAttribute = m_pAttributes; pAttribute; pAttribute = pAttribute->NextAttribute() )
|
|
{
|
|
pAttribute->OnUnserializationFinished();
|
|
}
|
|
|
|
// loop referencing attributes, and call OnAttributeChanged on them as well
|
|
if ( m_ref.m_attributes.m_hAttribute != DMATTRIBUTE_HANDLE_INVALID )
|
|
{
|
|
for ( DmAttributeList_t *pAttrLink = &m_ref.m_attributes; pAttrLink; pAttrLink = pAttrLink->m_pNext )
|
|
{
|
|
CDmAttribute *pAttr = g_pDataModel->GetAttribute( pAttrLink->m_hAttribute );
|
|
if ( !pAttr || pAttr->GetOwner()->GetFileId() == m_fileId )
|
|
continue; // attributes in this file will already have OnAttributeChanged called on them
|
|
|
|
pAttr->OnUnserializationFinished();
|
|
}
|
|
}
|
|
|
|
// Mostly used for backward compatibility reasons
|
|
CDmElement *pElement = g_pDataModel->GetElement( m_ref.m_hElement );
|
|
pElement->OnElementUnserialized();
|
|
|
|
// Force a resolve also, and set it up to remove it from the dirty list
|
|
// after unserialization is complete
|
|
pElement->Resolve();
|
|
MarkDirty( false );
|
|
MarkAttributesClean();
|
|
g_pDataModelImp->NotifyState( NOTIFY_CHANGE_TOPOLOGICAL );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CDmElement::IsBeingUnserialized() const
|
|
{
|
|
return m_bBeingUnserialized;
|
|
}
|
|
|
|
|
|
// Should only be called from datamodel, who will take care of changing the fileset entry as well
|
|
void CDmElement::ChangeHandle( DmElementHandle_t handle )
|
|
{
|
|
m_ref.m_hElement = handle;
|
|
}
|
|
|
|
// returns element reference struct w/ list of referrers and handle count
|
|
DmElementReference_t *CDmElement::GetReference()
|
|
{
|
|
return &m_ref;
|
|
}
|
|
|
|
void CDmElement::SetReference( const DmElementReference_t &ref )
|
|
{
|
|
Assert( !m_ref.IsWeaklyReferenced() );
|
|
m_ref = ref;
|
|
}
|
|
|
|
|
|
int CDmElement::EstimateMemoryUsage( CUtlHash< DmElementHandle_t > &visited, TraversalDepth_t depth, int *pCategories )
|
|
{
|
|
if ( visited.Find( m_ref.m_hElement ) != visited.InvalidHandle() )
|
|
return 0;
|
|
visited.Insert( m_ref.m_hElement );
|
|
|
|
int nDataModelUsage = g_pDataModelImp->EstimateMemoryOverhead( );
|
|
int nReferenceUsage = m_ref.EstimateMemoryOverhead();
|
|
CDmElement *pElement = g_pDataModel->GetElement( m_ref.m_hElement );
|
|
int nInternalUsage = sizeof( *this ) - sizeof( CUtlString ); // NOTE: The utlstring is the 'name' attribute var
|
|
int nOuterUsage = pElement->AllocatedSize() - nInternalUsage;
|
|
Assert( nOuterUsage >= 0 );
|
|
|
|
if ( pCategories )
|
|
{
|
|
pCategories[MEMORY_CATEGORY_OUTER] += nOuterUsage;
|
|
pCategories[MEMORY_CATEGORY_DATAMODEL] += nDataModelUsage;
|
|
pCategories[MEMORY_CATEGORY_REFERENCES] += nReferenceUsage;
|
|
pCategories[MEMORY_CATEGORY_ELEMENT_INTERNAL] += nInternalUsage;
|
|
}
|
|
|
|
int nAttributeDataUsage = 0;
|
|
for ( CDmAttribute *pAttr = m_pAttributes; pAttr; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
nAttributeDataUsage += pAttr->EstimateMemoryUsageInternal( visited, depth, pCategories );
|
|
}
|
|
|
|
return nInternalUsage + nDataModelUsage + nReferenceUsage + nOuterUsage + nAttributeDataUsage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// these functions are here for the mark and sweep algorithm for deleting orphaned subtrees
|
|
// it's conservative, so it can return true for orphaned elements but false really means it isn't accessible
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmElement::IsAccessible() const
|
|
{
|
|
return m_bIsAcessible;
|
|
}
|
|
|
|
void CDmElement::MarkAccessible( bool bAccessible )
|
|
{
|
|
m_bIsAcessible = bAccessible;
|
|
}
|
|
|
|
void CDmElement::MarkAccessible( TraversalDepth_t depth /* = TD_ALL */ )
|
|
{
|
|
if ( m_bIsAcessible )
|
|
return;
|
|
|
|
m_bIsAcessible = true;
|
|
|
|
for ( const CDmAttribute *pAttr = FirstAttribute(); pAttr != NULL; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
if ( !ShouldTraverse( pAttr, depth ) )
|
|
continue;
|
|
|
|
if ( pAttr->GetType() == AT_ELEMENT )
|
|
{
|
|
CDmElement *pChild = pAttr->GetValueElement<CDmElement>();
|
|
if ( !pChild )
|
|
continue;
|
|
pChild->MarkAccessible( depth );
|
|
}
|
|
else if ( pAttr->GetType() == AT_ELEMENT_ARRAY )
|
|
{
|
|
const CDmrElementArrayConst<> elementArrayAttr( pAttr );
|
|
int nChildren = elementArrayAttr.Count();
|
|
for ( int i = 0; i < nChildren; ++i )
|
|
{
|
|
CDmElement *pChild = elementArrayAttr[ i ];
|
|
if ( !pChild )
|
|
continue;
|
|
pChild->MarkAccessible( depth );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// returns the first path to the element found traversing all element/element array attributes - not necessarily the shortest
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// do we want a true visited set to avoid retraversing the same subtree over and over again?
|
|
// for most dag trees, it's probably a perf loss, since multiple instances are rare, (and searching the visited set costs log(n))
|
|
// for trees that include channels, it's probably a perf win, since many channels link into the same element most of the time
|
|
bool CDmElement::FindElement( const CDmElement *pElement, CUtlVector< ElementPathItem_t > &elementPath, TraversalDepth_t depth ) const
|
|
{
|
|
if ( this == pElement )
|
|
return true;
|
|
|
|
ElementPathItem_t search( GetHandle() );
|
|
if ( elementPath.Find( search ) != elementPath.InvalidIndex() )
|
|
return false;
|
|
|
|
int idx = elementPath.AddToTail( search );
|
|
ElementPathItem_t &pathItem = elementPath[ idx ];
|
|
|
|
for ( const CDmAttribute *pAttr = FirstAttribute(); pAttr != NULL; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
if ( !ShouldTraverse( pAttr, depth ) )
|
|
continue;
|
|
|
|
if ( pAttr->GetType() == AT_ELEMENT )
|
|
{
|
|
pathItem.hAttribute = const_cast< CDmAttribute* >( pAttr )->GetHandle();
|
|
pathItem.nIndex = -1;
|
|
|
|
CDmElement *pChild = pAttr->GetValueElement<CDmElement>();
|
|
if ( pChild && pChild->FindElement( pElement, elementPath, depth ) )
|
|
return true;
|
|
}
|
|
else if ( pAttr->GetType() == AT_ELEMENT_ARRAY )
|
|
{
|
|
pathItem.hAttribute = const_cast< CDmAttribute* >( pAttr )->GetHandle();
|
|
|
|
CDmrElementArrayConst<> elementArrayAttr( pAttr );
|
|
int nChildren = elementArrayAttr.Count();
|
|
for ( int i = 0; i < nChildren; ++i )
|
|
{
|
|
pathItem.nIndex = i;
|
|
|
|
CDmElement *pChild = elementArrayAttr[ i ];
|
|
if ( pChild && pChild->FindElement( pElement, elementPath, depth ) )
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
elementPath.Remove( idx );
|
|
return false;
|
|
}
|
|
|
|
bool CDmElement::FindReferer( DmElementHandle_t hElement, CUtlVector< ElementPathItem_t > &elementPath, TraversalDepth_t depth /* = TD_SHALLOW */ ) const
|
|
{
|
|
DmElementHandle_t hThis = GetHandle();
|
|
|
|
DmAttributeReferenceIterator_t hAttr = g_pDataModel->FirstAttributeReferencingElement( hThis );
|
|
for ( ; hAttr != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID; hAttr = g_pDataModel->NextAttributeReferencingElement( hAttr ) )
|
|
{
|
|
CDmAttribute *pAttr = g_pDataModel->GetAttribute( hAttr );
|
|
if ( !pAttr )
|
|
continue;
|
|
|
|
if ( !ShouldTraverse( pAttr, depth ) )
|
|
continue;
|
|
|
|
DmElementHandle_t hOwner = pAttr->GetOwner()->GetHandle();
|
|
if ( elementPath.Find( ElementPathItem_t( hOwner ) ) != elementPath.InvalidIndex() )
|
|
return false;
|
|
|
|
int i = elementPath.AddToTail();
|
|
ElementPathItem_t &item = elementPath[ i ];
|
|
item.hElement = hOwner;
|
|
item.hAttribute = pAttr->GetHandle();
|
|
item.nIndex = -1;
|
|
if ( pAttr->GetType() == AT_ELEMENT_ARRAY )
|
|
{
|
|
CDmrElementArray<> array( pAttr );
|
|
item.nIndex = array.Find( hThis );
|
|
}
|
|
|
|
if ( hOwner == hElement )
|
|
return true;
|
|
|
|
CDmElement *pOwner = GetElement< CDmElement >( hOwner );
|
|
if ( pOwner->FindReferer( hElement, elementPath, depth ) )
|
|
return true;
|
|
|
|
elementPath.Remove( i );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CDmElement::RemoveAllReferencesToElement( CDmElement *pElement )
|
|
{
|
|
for ( CDmAttribute *pAttr = FirstAttribute(); pAttr != NULL; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
if ( pAttr->GetType() == AT_ELEMENT )
|
|
{
|
|
CDmElement *pChild = pAttr->GetValueElement<CDmElement>();
|
|
if ( pChild == pElement )
|
|
{
|
|
pAttr->SetValue( DMELEMENT_HANDLE_INVALID );
|
|
}
|
|
}
|
|
else if ( pAttr->GetType() == AT_ELEMENT_ARRAY )
|
|
{
|
|
CDmrElementArray<> elementArrayAttr( pAttr );
|
|
int nChildren = elementArrayAttr.Count();
|
|
for ( int i = nChildren - 1; i >= 0; --i )
|
|
{
|
|
CDmElement *pChild = elementArrayAttr[ i ];
|
|
if ( pChild == pElement )
|
|
{
|
|
elementArrayAttr.Remove( i );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int CDmElement::EstimateMemoryUsage( TraversalDepth_t depth /* = TD_DEEP */ )
|
|
{
|
|
return g_pDataModel->EstimateMemoryUsage( GetHandle(), depth );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Implementation Undo for copied objects
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CDmElement* CDmElement::CopyInternal( TraversalDepth_t depth /* = TD_DEEP */ ) const
|
|
{
|
|
CDmElement *pCopy = GetElement< CDmElement >( g_pDataModel->CreateElement( GetType(), GetName(), GetFileId() ) );
|
|
if ( pCopy )
|
|
{
|
|
CopyAttributesTo( pCopy, depth );
|
|
}
|
|
return pCopy;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copy - implementation of shallow and deep element copying
|
|
// - allows attributes to be marked to always (or never) copy
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::CopyAttributesTo( CDmElement *pCopy, TraversalDepth_t depth ) const
|
|
{
|
|
CDisableUndoScopeGuard sg;
|
|
|
|
CUtlMap< DmElementHandle_t, DmElementHandle_t, int > refmap( DefLessFunc( DmElementHandle_t ) );
|
|
CopyAttributesTo( pCopy, refmap, depth );
|
|
|
|
CUtlHashFast< DmElementHandle_t > visited;
|
|
uint nPow2Size = 1;
|
|
while( nPow2Size < refmap.Count() )
|
|
{
|
|
nPow2Size <<= 1;
|
|
}
|
|
visited.Init( nPow2Size );
|
|
pCopy->FixupReferences( visited, refmap, depth );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copy an element-type attribute
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::CopyElementAttribute( const CDmAttribute *pSrcAttr, CDmAttribute *pDestAttr, CRefMap &refmap, TraversalDepth_t depth ) const
|
|
{
|
|
DmElementHandle_t hSrc = pSrcAttr->GetValue<DmElementHandle_t>();
|
|
CDmElement *pSrc = GetElement< CDmElement >( hSrc );
|
|
|
|
if ( pSrc == NULL )
|
|
{
|
|
pDestAttr->SetValue( DMELEMENT_HANDLE_INVALID );
|
|
return;
|
|
}
|
|
|
|
if ( pSrc->IsShared() )
|
|
{
|
|
pDestAttr->SetValue( pSrcAttr );
|
|
return;
|
|
}
|
|
|
|
int idx = refmap.Find( hSrc );
|
|
if ( idx != refmap.InvalidIndex() )
|
|
{
|
|
pDestAttr->SetValue( refmap[ idx ] );
|
|
return;
|
|
}
|
|
|
|
if ( ShouldTraverse( pSrcAttr, depth ) )
|
|
{
|
|
DmElementHandle_t hDest = pDestAttr->GetValue<DmElementHandle_t>();
|
|
if ( hDest == DMELEMENT_HANDLE_INVALID )
|
|
{
|
|
hDest = g_pDataModel->CreateElement( pSrc->GetType(), pSrc->GetName(), pSrc->GetFileId() );
|
|
pDestAttr->SetValue( hDest );
|
|
}
|
|
|
|
CDmElement *pDest = GetElement< CDmElement >( hDest );
|
|
pSrc->CopyAttributesTo( pDest, refmap, depth );
|
|
return;
|
|
}
|
|
|
|
pDestAttr->SetValue( pSrcAttr );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copy an element array-type attribute
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::CopyElementArrayAttribute( const CDmAttribute *pAttr, CDmAttribute *pCopyAttr, CRefMap &refmap, TraversalDepth_t depth ) const
|
|
{
|
|
CDmrElementArrayConst<> srcAttr( pAttr );
|
|
CDmrElementArray<> destAttr( pCopyAttr );
|
|
destAttr.RemoveAll(); // automatically releases each handle
|
|
|
|
bool bCopy = ShouldTraverse( pAttr, depth );
|
|
|
|
int n = srcAttr.Count();
|
|
destAttr.EnsureCapacity( n );
|
|
|
|
for ( int i = 0; i < n; ++i )
|
|
{
|
|
DmElementHandle_t hSrc = srcAttr.GetHandle( i );
|
|
CDmElement *pSrc = srcAttr[i];
|
|
|
|
if ( pSrc == NULL )
|
|
{
|
|
destAttr.AddToTail( DMELEMENT_HANDLE_INVALID );
|
|
continue;
|
|
}
|
|
|
|
if ( pSrc->IsShared() )
|
|
{
|
|
destAttr.AddToTail( srcAttr[ i ] );
|
|
continue;
|
|
}
|
|
|
|
int idx = refmap.Find( hSrc );
|
|
if ( idx != refmap.InvalidIndex() )
|
|
{
|
|
destAttr.AddToTail( refmap[ idx ] );
|
|
continue;
|
|
}
|
|
|
|
if ( bCopy )
|
|
{
|
|
DmElementHandle_t hDest = g_pDataModel->CreateElement( pSrc->GetType(), pSrc->GetName(), pSrc->GetFileId() );
|
|
destAttr.AddToTail( hDest );
|
|
CDmElement *pDest = GetElement< CDmElement >( hDest );
|
|
pSrc->CopyAttributesTo( pDest, refmap, depth );
|
|
continue;
|
|
}
|
|
|
|
destAttr.AddToTail( srcAttr[ i ] );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// internal recursive copy method
|
|
// builds refmap of old element's handle -> copy's handle, and uses it to fixup references
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::CopyAttributesTo( CDmElement *pCopy, CRefMap &refmap, TraversalDepth_t depth ) const
|
|
{
|
|
refmap.Insert( this->GetHandle(), pCopy->GetHandle() );
|
|
|
|
// loop attrs, copying - element (and element array) attrs can be marked to always copy deep(er)
|
|
for ( const CDmAttribute *pAttr = FirstAttribute(); pAttr != NULL; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
DmAttributeType_t type = pAttr->GetType();
|
|
const char *pAttrName = pAttr->GetName();
|
|
CDmAttribute *pCopyAttr = pCopy->GetAttribute( pAttrName );
|
|
|
|
if ( pCopyAttr == NULL )
|
|
{
|
|
pCopyAttr = pCopy->AddAttribute( pAttrName, type );
|
|
|
|
int flags = pAttr->GetFlags();
|
|
Assert( ( flags & FATTRIB_EXTERNAL ) == 0 );
|
|
flags &= ~FATTRIB_EXTERNAL;
|
|
|
|
pCopyAttr->ClearFlags();
|
|
pCopyAttr->AddFlag( flags );
|
|
}
|
|
|
|
// Temporarily remove the read-only flag from the copy while we copy into it
|
|
bool bReadOnly = pCopyAttr->IsFlagSet( FATTRIB_READONLY );
|
|
if ( bReadOnly )
|
|
{
|
|
pCopyAttr->RemoveFlag( FATTRIB_READONLY );
|
|
}
|
|
|
|
if ( type == AT_ELEMENT )
|
|
{
|
|
CopyElementAttribute( pAttr, pCopyAttr, refmap, depth );
|
|
}
|
|
else if ( type == AT_ELEMENT_ARRAY )
|
|
{
|
|
CopyElementArrayAttribute( pAttr, pCopyAttr, refmap, depth );
|
|
}
|
|
else
|
|
{
|
|
pCopyAttr->SetValue( pAttr );
|
|
}
|
|
|
|
if ( bReadOnly )
|
|
{
|
|
pCopyAttr->AddFlag( FATTRIB_READONLY );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// FixupReferences
|
|
// fixes up any references that Copy wasn't able to figure out
|
|
// example:
|
|
// during a shallow copy, a channel doesn't copy its target element,
|
|
// but the targets parent might decide to copy it, (later on in the travesal)
|
|
// so the channel needs to change to refer to the copy
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::FixupReferences( CUtlHashFast< DmElementHandle_t > &visited, const CRefMap &refmap, TraversalDepth_t depth )
|
|
{
|
|
if ( visited.Find( GetHandle() ) != visited.InvalidHandle() )
|
|
return;
|
|
|
|
visited.Insert( GetHandle(), DMELEMENT_HANDLE_INVALID ); // ignore data arguement - we're just using it as a set
|
|
|
|
// loop attrs, copying - element (and element array) attrs can be marked to always copy deep(er)
|
|
for ( CDmAttribute *pAttr = FirstAttribute(); pAttr != NULL; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
DmAttributeType_t type = pAttr->GetType();
|
|
bool bCopy = ShouldTraverse( pAttr, depth );
|
|
|
|
if ( type == AT_ELEMENT )
|
|
{
|
|
DmElementHandle_t handle = pAttr->GetValue<DmElementHandle_t>();
|
|
int idx = refmap.Find( handle );
|
|
if ( idx == refmap.InvalidIndex() )
|
|
{
|
|
CDmElement *pElement = GetElement< CDmElement >( handle );
|
|
if ( pElement == NULL || !bCopy )
|
|
continue;
|
|
|
|
pElement->FixupReferences( visited, refmap, depth );
|
|
}
|
|
else
|
|
{
|
|
pAttr->SetValue( refmap[ idx ] );
|
|
}
|
|
}
|
|
else if ( type == AT_ELEMENT_ARRAY )
|
|
{
|
|
CDmrElementArray<> attrArray( pAttr );
|
|
int nElements = attrArray.Count();
|
|
for ( int i = 0; i < nElements; ++i )
|
|
{
|
|
DmElementHandle_t handle = attrArray.GetHandle( i );
|
|
int idx = refmap.Find( handle );
|
|
if ( idx == refmap.InvalidIndex() )
|
|
{
|
|
CDmElement *pElement = GetElement< CDmElement >( handle );
|
|
if ( pElement == NULL || !bCopy )
|
|
continue;
|
|
|
|
pElement->FixupReferences( visited, refmap, depth );
|
|
}
|
|
else
|
|
{
|
|
attrArray.SetHandle( i, refmap[ idx ] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Change type (only possible when versioning file formats)
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::SetType( const char *pType )
|
|
{
|
|
if ( !g_pDataModelImp->IsCreatingUntypedElements() )
|
|
{
|
|
Warning( "Unable to set type unless you're creating untyped elements!\n" );
|
|
return;
|
|
}
|
|
|
|
m_Type = g_pDataModel->GetSymbol( pType );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// owning file
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::SetFileId( DmFileId_t fileid )
|
|
{
|
|
g_pDataModelImp->RemoveElementFromFile( m_ref.m_hElement, m_fileId );
|
|
m_fileId = fileid;
|
|
g_pDataModelImp->AddElementToFile( m_ref.m_hElement, fileid );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// recursively set fileid's, with option to only change elements in the matched file
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::SetFileId( DmFileId_t fileid, TraversalDepth_t depth, bool bOnlyIfMatch /* = false */ )
|
|
{
|
|
if ( depth != TD_NONE )
|
|
{
|
|
CUtlHashFast< DmElementHandle_t > visited;
|
|
visited.Init( 4096 ); // this will make visited behave reasonably (perf-wise) for trees w/ around 4k elements in them
|
|
SetFileId_R( visited, fileid, depth, GetFileId(), bOnlyIfMatch );
|
|
}
|
|
else
|
|
{
|
|
SetFileId( fileid );
|
|
}
|
|
}
|
|
|
|
void CDmElement::SetFileId_R( CUtlHashFast< DmElementHandle_t > &visited, DmFileId_t fileid, TraversalDepth_t depth, DmFileId_t match, bool bOnlyIfMatch )
|
|
{
|
|
if ( bOnlyIfMatch && match != GetFileId() )
|
|
return;
|
|
|
|
if ( visited.Find( GetHandle() ) != visited.InvalidHandle() )
|
|
return;
|
|
|
|
visited.Insert( GetHandle(), DMELEMENT_HANDLE_INVALID ); // ignore data arguement - we're just using it as a set
|
|
|
|
SetFileId( fileid );
|
|
|
|
for ( CDmAttribute *pAttr = FirstAttribute(); pAttr != NULL; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
DmAttributeType_t type = pAttr->GetType();
|
|
if ( !ShouldTraverse( pAttr, depth ) )
|
|
continue;
|
|
|
|
if ( type == AT_ELEMENT )
|
|
{
|
|
CDmElement *pElement = pAttr->GetValueElement<CDmElement>();
|
|
if ( pElement )
|
|
{
|
|
pElement->SetFileId_R( visited, fileid, depth, match, bOnlyIfMatch );
|
|
}
|
|
}
|
|
else if ( type == AT_ELEMENT_ARRAY )
|
|
{
|
|
CDmrElementArray<> attrArray( pAttr );
|
|
int nElements = attrArray.Count();
|
|
for ( int i = 0; i < nElements; ++i )
|
|
{
|
|
CDmElement *pElement = attrArray[ i ];
|
|
if ( pElement )
|
|
{
|
|
pElement->SetFileId_R( visited, fileid, depth, match, bOnlyIfMatch );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
DmElementHandle_t CDmElement::GetHandle() const
|
|
{
|
|
Assert( m_ref.m_hElement != DMELEMENT_HANDLE_INVALID );
|
|
return m_ref.m_hElement;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Iteration
|
|
//-----------------------------------------------------------------------------
|
|
int CDmElement::AttributeCount() const
|
|
{
|
|
int nAttrs = 0;
|
|
for ( CDmAttribute *pAttr = m_pAttributes; pAttr; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
++nAttrs;
|
|
}
|
|
return nAttrs;
|
|
}
|
|
|
|
CDmAttribute* CDmElement::FirstAttribute()
|
|
{
|
|
return m_pAttributes;
|
|
}
|
|
|
|
const CDmAttribute* CDmElement::FirstAttribute() const
|
|
{
|
|
return m_pAttributes;
|
|
}
|
|
|
|
bool CDmElement::HasAttribute( const char *pAttributeName, DmAttributeType_t type ) const
|
|
{
|
|
CDmAttribute *pAttribute = FindAttribute( pAttributeName );
|
|
if ( !pAttribute )
|
|
return false;
|
|
|
|
return ( type == AT_UNKNOWN || ( pAttribute->GetType() == type ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Implementation Undo for CDmAttributeTyped
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CUndoAttributeRemove : public CUndoElement
|
|
{
|
|
typedef CUndoElement BaseClass;
|
|
public:
|
|
CUndoAttributeRemove( CDmElement *pElement, CDmAttribute *pOldAttribute, const char *attributeName, DmAttributeType_t type )
|
|
: BaseClass( "CUndoAttributeRemove" ),
|
|
m_pElement( pElement ),
|
|
m_pOldAttribute( pOldAttribute ),
|
|
m_symAttribute( attributeName ),
|
|
m_Type( type )
|
|
{
|
|
Assert( pElement && pElement->GetFileId() != DMFILEID_INVALID );
|
|
}
|
|
|
|
~CUndoAttributeRemove()
|
|
{
|
|
// Kill old version...
|
|
CDmAttributeAccessor::DestroyAttribute( m_pOldAttribute );
|
|
}
|
|
|
|
virtual void Undo()
|
|
{
|
|
// Add it back in w/o any data
|
|
CDmAttribute *pAtt = m_pElement->AddAttribute( m_symAttribute.String(), m_Type );
|
|
if ( pAtt )
|
|
{
|
|
// Copy data from old version
|
|
pAtt->SetValue( m_pOldAttribute );
|
|
}
|
|
}
|
|
virtual void Redo()
|
|
{
|
|
m_pElement->RemoveAttribute( m_symAttribute.String() );
|
|
}
|
|
|
|
private:
|
|
CDmElement *m_pElement;
|
|
CUtlSymbol m_symAttribute;
|
|
DmAttributeType_t m_Type;
|
|
CDmAttribute *m_pOldAttribute;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Containing object
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::RemoveAttributeByPtrNoDelete( CDmAttribute *ptr )
|
|
{
|
|
for ( CDmAttribute **ppAttr = &m_pAttributes; *ppAttr; ppAttr = ( *ppAttr )->GetNextAttributeRef() )
|
|
{
|
|
if ( ptr == *ppAttr )
|
|
{
|
|
MarkDirty();
|
|
|
|
ptr->InvalidateHandle();
|
|
*ppAttr = ( *ppAttr )->NextAttribute();
|
|
|
|
g_pDataModelImp->NotifyState( NOTIFY_CHANGE_TOPOLOGICAL );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Attribute removal
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::RemoveAttribute( CDmAttribute **pAttrRef )
|
|
{
|
|
CDmAttribute *pAttrToDelete = *pAttrRef;
|
|
|
|
// Removal of external attributes is verboten
|
|
Assert( !pAttrToDelete->IsFlagSet( FATTRIB_EXTERNAL ) );
|
|
if( pAttrToDelete->IsFlagSet( FATTRIB_EXTERNAL ) )
|
|
return;
|
|
|
|
MarkDirty();
|
|
|
|
// UNDO Hook
|
|
bool storedbyundo = false;
|
|
if ( g_pDataModel->UndoEnabledForElement( this ) )
|
|
{
|
|
MEM_ALLOC_CREDIT_CLASS();
|
|
CUndoAttributeRemove *pUndo = new CUndoAttributeRemove( this, pAttrToDelete, pAttrToDelete->GetName(), pAttrToDelete->GetType() );
|
|
g_pDataModel->AddUndoElement( pUndo );
|
|
storedbyundo = true;
|
|
}
|
|
|
|
*pAttrRef = ( *pAttrRef )->NextAttribute();
|
|
|
|
if ( !storedbyundo )
|
|
{
|
|
CDmAttribute::DestroyAttribute( pAttrToDelete );
|
|
}
|
|
g_pDataModelImp->NotifyState( NOTIFY_CHANGE_TOPOLOGICAL );
|
|
}
|
|
|
|
|
|
void CDmElement::RemoveAttribute( const char *pAttributeName )
|
|
{
|
|
UtlSymId_t find = g_pDataModel->GetSymbol( pAttributeName );
|
|
for ( CDmAttribute **ppAttr = &m_pAttributes; *ppAttr; ppAttr = ( *ppAttr )->GetNextAttributeRef() )
|
|
{
|
|
if ( find == ( *ppAttr )->GetNameSymbol() )
|
|
{
|
|
RemoveAttribute( ppAttr );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDmElement::RemoveAttributeByPtr( CDmAttribute *pAttribute )
|
|
{
|
|
Assert( pAttribute );
|
|
for ( CDmAttribute **ppAttr = &m_pAttributes; *ppAttr; ppAttr = ( *ppAttr )->GetNextAttributeRef() )
|
|
{
|
|
if ( pAttribute == *ppAttr )
|
|
{
|
|
RemoveAttribute( ppAttr );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets an attribute from a string
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::SetValueFromString( const char *pAttributeName, const char *pValue )
|
|
{
|
|
CDmAttribute *pAttribute = FindAttribute( pAttributeName );
|
|
if ( pAttribute )
|
|
{
|
|
pAttribute->SetValueFromString( pValue );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Writes an attribute as a string
|
|
//-----------------------------------------------------------------------------
|
|
const char *CDmElement::GetValueAsString( const char *pAttributeName, char *pBuffer, size_t nBufLen ) const
|
|
{
|
|
Assert( pBuffer );
|
|
|
|
const CDmAttribute *pAttribute = FindAttribute( pAttributeName );
|
|
if ( pAttribute )
|
|
return pAttribute->GetValueAsString( pBuffer, nBufLen );
|
|
|
|
pBuffer[ 0 ] = 0;
|
|
return pBuffer;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Implementation Undo for CDmAttributeTyped
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CUndoAttributeAdd : public CUndoElement
|
|
{
|
|
typedef CUndoElement BaseClass;
|
|
|
|
public:
|
|
CUndoAttributeAdd( CDmElement *pElement, const char *attributeName )
|
|
: BaseClass( "CUndoAttributeAdd" ),
|
|
m_hElement( pElement->GetHandle() ),
|
|
m_symAttribute( attributeName ),
|
|
m_pAttribute( NULL ),
|
|
m_bHoldingPtr( false )
|
|
{
|
|
Assert( pElement && pElement->GetFileId() != DMFILEID_INVALID );
|
|
}
|
|
|
|
~CUndoAttributeAdd()
|
|
{
|
|
if ( m_bHoldingPtr && m_pAttribute )
|
|
{
|
|
CDmAttributeAccessor::DestroyAttribute( m_pAttribute );
|
|
m_pAttribute = NULL;
|
|
}
|
|
}
|
|
|
|
void SetAttributePtr( CDmAttribute *pAttribute )
|
|
{
|
|
m_pAttribute = pAttribute;
|
|
}
|
|
|
|
virtual void Undo()
|
|
{
|
|
if ( GetElement() )
|
|
{
|
|
CDmeElementAccessor::RemoveAttributeByPtrNoDelete( GetElement(), m_pAttribute );
|
|
m_bHoldingPtr = true;
|
|
}
|
|
}
|
|
|
|
virtual void Redo()
|
|
{
|
|
if ( !GetElement() )
|
|
return;
|
|
|
|
CDmeElementAccessor::AddAttributeByPtr( GetElement(), m_pAttribute );
|
|
m_bHoldingPtr = false;
|
|
}
|
|
|
|
virtual const char *GetDesc()
|
|
{
|
|
static char buf[ 128 ];
|
|
|
|
const char *base = BaseClass::GetDesc();
|
|
Q_snprintf( buf, sizeof( buf ), "%s(%s)", base, m_symAttribute.String() );
|
|
return buf;
|
|
}
|
|
|
|
private:
|
|
CDmElement *GetElement()
|
|
{
|
|
return g_pDataModel->GetElement( m_hElement );
|
|
}
|
|
|
|
DmElementHandle_t m_hElement;
|
|
CUtlSymbol m_symAttribute;
|
|
CDmAttribute *m_pAttribute;
|
|
bool m_bHoldingPtr;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Adds, removes attributes
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::AddAttributeByPtr( CDmAttribute *ptr )
|
|
{
|
|
MarkDirty();
|
|
|
|
for ( CDmAttribute *pAttr = m_pAttributes; pAttr; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
if ( pAttr == ptr )
|
|
{
|
|
Assert( 0 );
|
|
return;
|
|
}
|
|
}
|
|
|
|
*( ptr->GetNextAttributeRef() ) = m_pAttributes;
|
|
m_pAttributes = ptr;
|
|
|
|
g_pDataModelImp->NotifyState( NOTIFY_CHANGE_TOPOLOGICAL );
|
|
}
|
|
|
|
CDmAttribute *CDmElement::CreateAttribute( const char *pAttributeName, DmAttributeType_t type )
|
|
{
|
|
Assert( !HasAttribute( pAttributeName ) );
|
|
MarkDirty( );
|
|
|
|
// UNDO Hook
|
|
CUndoAttributeAdd *pUndo = NULL;
|
|
if ( g_pDataModel->UndoEnabledForElement( this ) )
|
|
{
|
|
MEM_ALLOC_CREDIT_CLASS();
|
|
pUndo = new CUndoAttributeAdd( this, pAttributeName );
|
|
g_pDataModel->AddUndoElement( pUndo );
|
|
}
|
|
|
|
CDmAttribute *pAttribute = NULL;
|
|
{
|
|
CDisableUndoScopeGuard guard;
|
|
pAttribute = CDmAttribute::CreateAttribute( this, type, pAttributeName );
|
|
*( pAttribute->GetNextAttributeRef() ) = m_pAttributes;
|
|
m_pAttributes = pAttribute;
|
|
if ( pUndo )
|
|
{
|
|
pUndo->SetAttributePtr( pAttribute );
|
|
}
|
|
g_pDataModelImp->NotifyState( NOTIFY_CHANGE_TOPOLOGICAL );
|
|
}
|
|
return pAttribute;
|
|
}
|
|
|
|
CDmAttribute* CDmElement::AddExternalAttribute( const char *pAttributeName, DmAttributeType_t type, void *pMemory )
|
|
{
|
|
MarkDirty( );
|
|
|
|
// Add will only add the attribute doesn't already exist
|
|
if ( HasAttribute( pAttributeName ) )
|
|
{
|
|
Assert( 0 );
|
|
return NULL;
|
|
}
|
|
|
|
// UNDO Hook
|
|
CUndoAttributeAdd *pUndo = NULL;
|
|
if ( g_pDataModel->UndoEnabledForElement( this ) )
|
|
{
|
|
MEM_ALLOC_CREDIT_CLASS();
|
|
pUndo = new CUndoAttributeAdd( this, pAttributeName );
|
|
g_pDataModel->AddUndoElement( pUndo );
|
|
}
|
|
|
|
CDmAttribute *pAttribute = NULL;
|
|
{
|
|
CDisableUndoScopeGuard guard;
|
|
pAttribute = CDmAttribute::CreateExternalAttribute( this, type, pAttributeName, pMemory );
|
|
*( pAttribute->GetNextAttributeRef() ) = m_pAttributes;
|
|
m_pAttributes = pAttribute;
|
|
if ( pUndo )
|
|
{
|
|
pUndo->SetAttributePtr( pAttribute );
|
|
}
|
|
g_pDataModelImp->NotifyState( NOTIFY_CHANGE_TOPOLOGICAL );
|
|
}
|
|
return pAttribute;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Find an attribute in the list
|
|
//-----------------------------------------------------------------------------
|
|
CDmAttribute *CDmElement::FindAttribute( const char *pAttributeName ) const
|
|
{
|
|
UtlSymId_t find = g_pDataModel->GetSymbol( pAttributeName );
|
|
|
|
for ( CDmAttribute *pAttr = m_pAttributes; pAttr; pAttr = pAttr->NextAttribute() )
|
|
{
|
|
if ( find == pAttr->GetNameSymbol() )
|
|
return pAttr;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// attribute renaming
|
|
//-----------------------------------------------------------------------------
|
|
void CDmElement::RenameAttribute( const char *pAttributeName, const char *pNewName )
|
|
{
|
|
CDmAttribute *pAttr = FindAttribute( pAttributeName );
|
|
if ( pAttr )
|
|
{
|
|
pAttr->SetName( pNewName );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// allows elements to chain OnAttributeChanged up to their parents (or at least, referrers)
|
|
//-----------------------------------------------------------------------------
|
|
void InvokeOnAttributeChangedOnReferrers( DmElementHandle_t hElement, CDmAttribute *pChangedAttr )
|
|
{
|
|
DmAttributeReferenceIterator_t ai = g_pDataModel->FirstAttributeReferencingElement( hElement );
|
|
for ( ; ai != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID; ai = g_pDataModel->NextAttributeReferencingElement( ai ) )
|
|
{
|
|
CDmAttribute *pAttr = g_pDataModel->GetAttribute( ai );
|
|
Assert( pAttr );
|
|
if ( !pAttr )
|
|
continue;
|
|
|
|
if ( pAttr->IsFlagSet( FATTRIB_NEVERCOPY ) )
|
|
continue;
|
|
|
|
CDmElement *pOwner = pAttr->GetOwner();
|
|
Assert( pOwner );
|
|
if ( !pOwner )
|
|
continue;
|
|
|
|
pOwner->OnAttributeChanged( pChangedAttr );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Destroys an element and all elements it refers to via attributes
|
|
//-----------------------------------------------------------------------------
|
|
void DestroyElement( CDmElement *pElement, TraversalDepth_t depth )
|
|
{
|
|
if ( !pElement )
|
|
return;
|
|
|
|
CDmAttribute* pAttribute;
|
|
for ( pAttribute = pElement->FirstAttribute(); pAttribute; pAttribute = pAttribute->NextAttribute() )
|
|
{
|
|
if ( !ShouldTraverse( pAttribute, depth ) )
|
|
continue;
|
|
|
|
switch( pAttribute->GetType() )
|
|
{
|
|
case AT_ELEMENT:
|
|
{
|
|
CDmElement *pChild = pAttribute->GetValueElement<CDmElement>();
|
|
DestroyElement( pChild, depth );
|
|
}
|
|
break;
|
|
|
|
case AT_ELEMENT_ARRAY:
|
|
{
|
|
CDmrElementArray<> array( pAttribute );
|
|
int nElements = array.Count();
|
|
for ( int i = 0; i < nElements; ++i )
|
|
{
|
|
CDmElement *pChild = array[ i ];
|
|
DestroyElement( pChild, depth );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_pDataModel->DestroyElement( pElement->GetHandle() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// copy groups of elements together so that references between them are maintained
|
|
//-----------------------------------------------------------------------------
|
|
void CopyElements( const CUtlVector< CDmElement* > &from, CUtlVector< CDmElement* > &to, TraversalDepth_t depth /* = TD_DEEP */ )
|
|
{
|
|
CDisableUndoScopeGuard sg;
|
|
|
|
CUtlMap< DmElementHandle_t, DmElementHandle_t, int > refmap( DefLessFunc( DmElementHandle_t ) );
|
|
|
|
int c = from.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CDmElement *pFrom = from[ i ];
|
|
CDmElement *pCopy = GetElement< CDmElement >( g_pDataModel->CreateElement( pFrom->GetType(), pFrom->GetName(), pFrom->GetFileId() ) );
|
|
if ( pCopy )
|
|
{
|
|
pFrom->CopyAttributesTo( pCopy, refmap, depth );
|
|
}
|
|
to.AddToTail( pCopy );
|
|
}
|
|
|
|
CUtlHashFast< DmElementHandle_t > visited;
|
|
uint nPow2Size = 1;
|
|
while( nPow2Size < refmap.Count() )
|
|
{
|
|
nPow2Size <<= 1;
|
|
}
|
|
visited.Init( nPow2Size );
|
|
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
to[ i ]->FixupReferences( visited, refmap, depth );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// element-specific unique name generation methods
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
struct ElementArrayNameAccessor
|
|
{
|
|
ElementArrayNameAccessor( const CUtlVector< DmElementHandle_t > &array ) : m_array( array ) {}
|
|
int Count() const
|
|
{
|
|
return m_array.Count();
|
|
}
|
|
const char *operator[]( int i ) const
|
|
{
|
|
CDmElement *pElement = GetElement< CDmElement >( m_array[ i ] );
|
|
return pElement ? pElement->GetName() : NULL;
|
|
}
|
|
private:
|
|
const CUtlVector< DmElementHandle_t > &m_array;
|
|
};
|
|
|
|
// returns startindex if none found, 2 if only "prefix" found, and n+1 if "prefixn" found
|
|
int GenerateUniqueNameIndex( const char *prefix, const CUtlVector< DmElementHandle_t > &array, int startindex )
|
|
{
|
|
return V_GenerateUniqueNameIndex( prefix, ElementArrayNameAccessor( array ), startindex );
|
|
}
|
|
|
|
bool GenerateUniqueName( char *name, int memsize, const char *prefix, const CUtlVector< DmElementHandle_t > &array )
|
|
{
|
|
return V_GenerateUniqueName( name, memsize, prefix, ElementArrayNameAccessor( array ) );
|
|
}
|
|
|
|
void MakeElementNameUnique( CDmElement *pElement, const char *prefix, const CUtlVector< DmElementHandle_t > &array, bool forceIndex )
|
|
{
|
|
if ( pElement == NULL || prefix == NULL )
|
|
return;
|
|
|
|
int i = GenerateUniqueNameIndex( prefix, array );
|
|
if ( i <= 0 )
|
|
{
|
|
if ( !forceIndex )
|
|
{
|
|
pElement->SetName( prefix );
|
|
return;
|
|
}
|
|
i = 1; // 1 means that no names of "prefix*" were found, but we want to generate a 1-based index
|
|
}
|
|
|
|
int prefixLength = Q_strlen( prefix );
|
|
int newlen = prefixLength + ( int )log10( ( float )i ) + 1;
|
|
if ( newlen < 256 )
|
|
{
|
|
char name[256];
|
|
Q_snprintf( name, sizeof( name ), "%s%d", prefix, i );
|
|
pElement->SetName( name );
|
|
}
|
|
else
|
|
{
|
|
char *name = new char[ newlen + 1 ];
|
|
Q_snprintf( name, sizeof( name ), "%s%d", prefix, i );
|
|
pElement->SetName( name );
|
|
delete[] name;
|
|
}
|
|
}
|
|
|
|
void RemoveElementFromRefereringAttributes( CDmElement *pElement, bool bPreserveOrder /*= true*/ )
|
|
{
|
|
for ( DmAttributeReferenceIterator_t i = g_pDataModel->FirstAttributeReferencingElement( pElement->GetHandle() );
|
|
i != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
|
|
i = g_pDataModel->FirstAttributeReferencingElement( pElement->GetHandle() ) ) // always re-get the FIRST attribute, since we're removing from this list
|
|
{
|
|
CDmAttribute *pAttribute = g_pDataModel->GetAttribute( i );
|
|
Assert( pAttribute );
|
|
if ( !pAttribute )
|
|
continue;
|
|
|
|
if ( IsArrayType( pAttribute->GetType() ) )
|
|
{
|
|
CDmrElementArray<> array( pAttribute );
|
|
int iElem = array.Find( pElement );
|
|
Assert( iElem != array.InvalidIndex() );
|
|
if ( bPreserveOrder )
|
|
{
|
|
array.Remove( iElem );
|
|
}
|
|
else
|
|
{
|
|
array.FastRemove( iElem );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pAttribute->SetValue( DMELEMENT_HANDLE_INVALID );
|
|
}
|
|
}
|
|
}
|