{

ElementPathItem_t( DmElementHandle_t hElem = DMELEMENT_HANDLE_INVALID,

DmAttributeHandle_t hAttr = DMATTRIBUTE_HANDLE_INVALID,

int idx = -1 )

: hElement( hElem ), hAttribute( hAttr ), nIndex( idx )

{

}

// only uses hElement so that it can be used to search for elements

bool operator==( const ElementPathItem_t &that ) const

{

return hElement == that.hElement;

}

DmElementHandle_t hElement;

DmAttributeHandle_t hAttribute;

int nIndex;

{

DmAttributeList_t() : m_hAttribute( DMATTRIBUTE_HANDLE_INVALID ), m_pNext( NULL ) {}

DmAttributeHandle_t m_hAttribute;

DmAttributeList_t *m_pNext;

{

protected:

void Ref ( DmElementHandle_t hElement, bool bStrong );

void Unref( DmElementHandle_t hElement, bool bStrong );

{

explicit DmElementReference_t( DmElementHandle_t hElement = DMELEMENT_HANDLE_INVALID ) :

m_hElement( hElement ), m_nWeakHandleCount( 0 ), m_nStrongHandleCount( 0 )

{

}

DmElementReference_t( const DmElementReference_t &that ) :

m_hElement( that.m_hElement ), m_nWeakHandleCount( that.m_nWeakHandleCount ),

m_nStrongHandleCount( that.m_nStrongHandleCount ), m_attributes( that.m_attributes )

{

}

DmElementReference_t &operator=( const DmElementReference_t &that )

{

m_hElement = that.m_hElement;

m_nWeakHandleCount = that.m_nWeakHandleCount;

m_nStrongHandleCount = that.m_nStrongHandleCount;

m_attributes.m_hAttribute = that.m_attributes.m_hAttribute;

m_attributes.m_pNext = that.m_attributes.m_pNext;

return *this;

}

~DmElementReference_t()

{

// Assert( !IsStronglyReferenced() );

}

void AddAttribute( CDmAttribute *pAttribute );

void RemoveAttribute( CDmAttribute *pAttribute );

bool IsStronglyReferenced() // should this element be kept around (even if it's DmElementHandle_t is invalidated)

{

return m_attributes.m_hAttribute != DMATTRIBUTE_HANDLE_INVALID || m_nStrongHandleCount > 0;

}

bool IsWeaklyReferenced() // should we keep this element's DmElementHandle_t mapped to it's id (even if the element is deleted)

{

return IsStronglyReferenced() || m_nWeakHandleCount > 0;

}

int EstimateMemoryOverhead()

{

int nBytes = 0;

for ( DmAttributeList_t *pLink = m_attributes.m_pNext; pLink; pLink = pLink->m_pNext )

{

nBytes += sizeof( DmAttributeList_t );

}

return nBytes;

}

DmElementHandle_t m_hElement;

unsigned short m_nWeakHandleCount; // CDmeHandle<T> - for auto-hookup once the element comes back, mainly used by UI

unsigned short m_nStrongHandleCount; // CDmeCountedElementRef - for preventing elements from being truly deleted, mainly used by undo and file root

DmAttributeList_t m_attributes;

{

public:

// Can be overridden by derived classes

virtual void OnAttributeChanged( CDmAttribute *pAttribute ) {}

virtual void PreAttributeChanged( CDmAttribute *pAttribute ) {}

virtual void OnAttributeArrayElementAdded( CDmAttribute *pAttribute, int nFirstElem, int nLastElem ) {}

virtual void OnAttributeArrayElementRemoved( CDmAttribute *pAttribute, int nFirstElem, int nLastElem ) {}

virtual void Resolve() {}

virtual bool IsA( UtlSymId_t typeSymbol ) const;

virtual int GetInheritanceDepth( UtlSymId_t typeSymbol ) const;

virtual void OnElementUnserialized() {}

virtual int AllocatedSize() const { return sizeof( CDmElement ); }

// Returns the element handle

DmElementHandle_t GetHandle() const;

// Attribute iteration, finding

// NOTE: Passing a type into GetAttribute will return NULL if the attribute exists but isn't that type

bool HasAttribute( const char *pAttributeName, DmAttributeType_t type = AT_UNKNOWN ) const;

CDmAttribute *GetAttribute( const char *pAttributeName, DmAttributeType_t type = AT_UNKNOWN );

const CDmAttribute *GetAttribute( const char *pAttributeName, DmAttributeType_t type = AT_UNKNOWN ) const;

int AttributeCount() const;

CDmAttribute* FirstAttribute();

const CDmAttribute* FirstAttribute() const;

// Element name, type, ID

// WARNING: SetType() should only be used by format conversion methods (dmxconvert)

UtlSymId_t GetType() const;

const char * GetTypeString() const;

const char * GetName() const;

const DmObjectId_t& GetId() const;

void SetType( const char *pType );

void SetName( const char* pName );

// Attribute management

CDmAttribute * AddAttribute( const char *pAttributeName, DmAttributeType_t type );

template< class E > CDmAttribute* AddAttributeElement( const char *pAttributeName );

template< class E > CDmAttribute* AddAttributeElementArray( const char *pAttributeName );

void RemoveAttribute( const char *pAttributeName );

void RemoveAttributeByPtr( CDmAttribute *pAttributeName );

void RenameAttribute( const char *pAttributeName, const char *pNewName );

// get attribute value

template< class T > const T& GetValue( const char *pAttributeName ) const;

template< class T > const T& GetValue( const char *pAttributeName, const T& defaultValue ) const;

const char * GetValueString( const char *pAttributeName ) const;

template< class E > E* GetValueElement( const char *pAttributeName ) const;

// set attribute value

CDmAttribute* SetValue( const char *pAttributeName, const void *value, size_t size );

template< class T > CDmAttribute* SetValue( const char *pAttributeName, const T& value );

template< class E > CDmAttribute* SetValue( const char *pAttributeName, E* value );

// set attribute value if the attribute doesn't already exist

CDmAttribute* InitValue( const char *pAttributeName, const void *value, size_t size );

template< class T > CDmAttribute* InitValue( const char *pAttributeName, const T& value );

template< class E > CDmAttribute* InitValue( const char *pAttributeName, E* value );

// Parses an attribute from a string

// Doesn't create an attribute if it doesn't exist and always preserves attribute type

void SetValueFromString( const char *pAttributeName, const char *value );

const char *GetValueAsString( const char *pAttributeName, char *pBuffer, size_t buflen ) const;

// Helpers for our RTTI

template< class E > bool IsA() const;

bool IsA( const char *pTypeName ) const;

int GetInheritanceDepth( const char *pTypeName ) const;

static CUtlSymbol GetStaticTypeSymbol();

// Indicates whether this element should be copied or not

void SetShared( bool bShared );

bool IsShared() const;

// Copies an element and all its attributes

CDmElement* Copy( TraversalDepth_t depth = TD_DEEP ) const;

// Copies attributes from a specified element

void CopyAttributesTo( CDmElement *pCopy, TraversalDepth_t depth = TD_DEEP ) const;

// recursively set fileid's, with option to only change elements in the matched file

void SetFileId( DmFileId_t fileid, TraversalDepth_t depth, bool bOnlyIfMatch = false );

DmFileId_t GetFileId() const;

bool IsAccessible() const;

void MarkAccessible( bool bAccessible );

void MarkAccessible( TraversalDepth_t depth = TD_ALL );

// returns the first path to the element found traversing all element/element

// array attributes - not necessarily the shortest.

// cycle-safe (skips any references to elements in the current path)

// but may re-traverse elements via different paths

bool FindElement( const CDmElement *pElement, CUtlVector< ElementPathItem_t > &elementPath, TraversalDepth_t depth ) const;

bool FindReferer( DmElementHandle_t hElement, CUtlVector< ElementPathItem_t > &elementPath, TraversalDepth_t depth ) const;

void RemoveAllReferencesToElement( CDmElement *pElement );

bool IsStronglyReferenced() { return m_ref.IsStronglyReferenced(); }

// Estimates the memory usage of the element, its attributes, and child elements

int EstimateMemoryUsage( TraversalDepth_t depth = TD_DEEP );

protected:

// NOTE: These are protected to ensure that the factory is the only thing that can create these

CDmElement( DmElementHandle_t handle, const char *objectType, const DmObjectId_t &id, const char *objectName, DmFileId_t fileid );

virtual ~CDmElement();

// Used by derived classes to do construction and setting up CDmaVars

void OnConstruction() { }

void OnDestruction() { }

virtual void PerformConstruction();

virtual void PerformDestruction();

// Internal methods related to RTII

static void SetTypeSymbol( CUtlSymbol sym );

static bool IsA_Implementation( CUtlSymbol typeSymbol );

static int GetInheritanceDepth_Implementation( CUtlSymbol typeSymbol, int nCurrentDepth );

// Internal method for creating a copy of this element

CDmElement* CopyInternal( TraversalDepth_t depth = TD_DEEP ) const;

// helper for making attributevarelementarray cleanup easier

template< class T > static void DeleteAttributeVarElementArray( T &array );

private:

typedef CUtlMap< DmElementHandle_t, DmElementHandle_t, int > CRefMap;

// Bogus constructor

CDmElement();

// internal recursive copy method - builds refmap of old element's handle -> copy's handle, and uses it to fixup references

void CopyAttributesTo( CDmElement *pCopy, CRefMap &refmap, TraversalDepth_t depth ) const;

void CopyElementAttribute( const CDmAttribute *pAttr, CDmAttribute *pCopyAttr, CRefMap &refmap, TraversalDepth_t depth ) const;

void CopyElementArrayAttribute( const CDmAttribute *pAttr, CDmAttribute *pCopyAttr, CRefMap &refmap, TraversalDepth_t depth ) const;

void FixupReferences( CUtlHashFast< DmElementHandle_t > &visited, const CRefMap &refmap, TraversalDepth_t depth );

void SetFileId( DmFileId_t fileid );

void SetFileId_R( CUtlHashFast< DmElementHandle_t > &visited, DmFileId_t fileid, TraversalDepth_t depth, DmFileId_t match, bool bOnlyIfMatch );

CDmAttribute* CreateAttribute( const char *pAttributeName, DmAttributeType_t type );

void RemoveAttribute( CDmAttribute **pAttrRef );

CDmAttribute* AddExternalAttribute( const char *pAttributeName, DmAttributeType_t type, void *pMemory );

CDmAttribute *FindAttribute( const char *pAttributeName ) const;

void Purge();

void SetId( const DmObjectId_t &id );

bool IsDirty() const;

void MarkDirty( bool dirty = true );

void MarkAttributesClean();

void MarkBeingUnserialized( bool beingUnserialized = true );

bool IsBeingUnserialized() const;

// Used by the undo system only.

void AddAttributeByPtr( CDmAttribute *ptr );

void RemoveAttributeByPtrNoDelete( CDmAttribute *ptr );

// Should only be called from datamodel, who will take care of changing the fileset entry as well

void ChangeHandle( DmElementHandle_t handle );

// returns element reference struct w/ list of referrers and handle count

DmElementReference_t* GetReference();

void SetReference( const DmElementReference_t &ref );

// Estimates memory usage

int EstimateMemoryUsage( CUtlHash< DmElementHandle_t > &visited, TraversalDepth_t depth, int *pCategories );

protected:

CDmaString m_Name;

private:

CDmAttribute *m_pAttributes;

DmElementReference_t m_ref;

UtlSymId_t m_Type;

bool m_bDirty : 1;

bool m_bBeingUnserialized : 1;

bool m_bIsAcessible : 1;

unsigned char m_nReserved; // Makes Id be quad aligned

DmObjectId_t m_Id;

DmFileId_t m_fileId;

// Stores the type symbol

static CUtlSymbol m_classType;

// Factories can access our constructors

template <class T> friend class CDmElementFactory;

template <class T> friend class CDmAbstractElementFactory;

template< class T > friend class CDmaVar;

template< class T > friend class CDmaArray;

template< class T > friend class CDmaElementArray;

template< class T, class B > friend class CDmaDecorator;

template< class T > friend class CDmrElementArray;

friend class CDmElementFactoryDefault;

friend class CDmeElementAccessor;

friend class CDmeOperator;

friend void CopyElements( const CUtlVector< CDmElement* > &from, CUtlVector< CDmElement* > &to, TraversalDepth_t depth );

{

if ( pElement )

{

g_pDataModel->DestroyElement( pElement->GetHandle() );

}

{

if ( bShared )

{

SetValue< bool >( "shared", true );

}

else

{

RemoveAttribute( "shared" );

}

{

CUtlSymbol typeSymbol = g_pDataModel->GetSymbol( pTypeName );

return IsA( typeSymbol );

{

int nElements = array.Count();

for ( int i = 0; i < nElements; ++i )

{

g_pDataModel->DestroyElement( array.GetHandle( i ) );

}

array.RemoveAll();