619 lines
23 KiB
C++
619 lines
23 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef DMELEMENT_H
|
|
#define DMELEMENT_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "tier1/utlmap.h"
|
|
#include "tier1/utlhash.h"
|
|
#include "tier1/utlvector.h"
|
|
#include "tier1/utlsymbol.h"
|
|
#include "datamodel/attributeflags.h"
|
|
#include "datamodel/idatamodel.h"
|
|
#include "datamodel/dmvar.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
typedef bool (CDmElement::*pfnCommandMethod)( const char *command, const char *args );
|
|
|
|
// element/element array traversal path item - assumes the full path does NOT contain cycles
|
|
struct ElementPathItem_t
|
|
{
|
|
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;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// singly-linked attribute list
|
|
//-----------------------------------------------------------------------------
|
|
struct DmAttributeList_t
|
|
{
|
|
DmAttributeList_t() : m_hAttribute( DMATTRIBUTE_HANDLE_INVALID ), m_pNext( NULL ) {}
|
|
DmAttributeHandle_t m_hAttribute;
|
|
DmAttributeList_t *m_pNext;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// helper class to allow CDmeHandle access to g_pDataModelImp
|
|
//-----------------------------------------------------------------------------
|
|
class CDmeElementRefHelper
|
|
{
|
|
protected:
|
|
void Ref ( DmElementHandle_t hElement, bool bStrong );
|
|
void Unref( DmElementHandle_t hElement, bool bStrong );
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// element reference struct - containing attribute referrers and handle refcount
|
|
//-----------------------------------------------------------------------------
|
|
struct DmElementReference_t
|
|
{
|
|
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;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Base DmElement we inherit from in higher-level classes
|
|
//-----------------------------------------------------------------------------
|
|
class CDmElement
|
|
{
|
|
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 );
|
|
};
|
|
|
|
|
|
|
|
inline void DestroyElement( CDmElement *pElement )
|
|
{
|
|
if ( pElement )
|
|
{
|
|
g_pDataModel->DestroyElement( pElement->GetHandle() );
|
|
}
|
|
}
|
|
|
|
void DestroyElement( CDmElement *pElement, TraversalDepth_t depth );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// allows elements to chain OnAttributeChanged up to their parents (or at least, referrers)
|
|
//-----------------------------------------------------------------------------
|
|
void InvokeOnAttributeChangedOnReferrers( DmElementHandle_t hElement, CDmAttribute *pChangedAttr );
|
|
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the type, name, id, fileId
|
|
//-----------------------------------------------------------------------------
|
|
inline UtlSymId_t CDmElement::GetType() const
|
|
{
|
|
return m_Type;
|
|
}
|
|
|
|
inline const char *CDmElement::GetTypeString() const
|
|
{
|
|
return g_pDataModel->GetString( m_Type );
|
|
}
|
|
|
|
inline const char *CDmElement::GetName() const
|
|
{
|
|
return m_Name.Get();
|
|
}
|
|
|
|
inline void CDmElement::SetName( const char* pName )
|
|
{
|
|
m_Name.Set( pName );
|
|
}
|
|
|
|
inline const DmObjectId_t& CDmElement::GetId() const
|
|
{
|
|
return m_Id;
|
|
}
|
|
|
|
inline DmFileId_t CDmElement::GetFileId() const
|
|
{
|
|
return m_fileId;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Controls whether the element should be copied by default
|
|
//-----------------------------------------------------------------------------
|
|
inline void CDmElement::SetShared( bool bShared )
|
|
{
|
|
if ( bShared )
|
|
{
|
|
SetValue< bool >( "shared", true );
|
|
}
|
|
else
|
|
{
|
|
RemoveAttribute( "shared" );
|
|
}
|
|
}
|
|
|
|
inline bool CDmElement::IsShared() const
|
|
{
|
|
return GetValue< bool >( "shared" ); // if attribute doesn't exist, returns default bool value, which is false
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copies attributes from a specified element
|
|
//-----------------------------------------------------------------------------
|
|
inline CDmElement* CDmElement::Copy( TraversalDepth_t depth ) const
|
|
{
|
|
return CopyInternal( depth );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// RTTI
|
|
//-----------------------------------------------------------------------------
|
|
inline bool CDmElement::IsA_Implementation( CUtlSymbol typeSymbol )
|
|
{
|
|
return ( m_classType == typeSymbol ) || ( UTL_INVAL_SYMBOL == typeSymbol );
|
|
}
|
|
|
|
inline int CDmElement::GetInheritanceDepth_Implementation( CUtlSymbol typeSymbol, int nCurrentDepth )
|
|
{
|
|
return IsA_Implementation( typeSymbol ) ? nCurrentDepth : -1;
|
|
}
|
|
|
|
inline CUtlSymbol CDmElement::GetStaticTypeSymbol()
|
|
{
|
|
return m_classType;
|
|
}
|
|
|
|
inline bool CDmElement::IsA( const char *pTypeName ) const
|
|
{
|
|
CUtlSymbol typeSymbol = g_pDataModel->GetSymbol( pTypeName );
|
|
return IsA( typeSymbol );
|
|
}
|
|
|
|
template< class E > inline bool CDmElement::IsA() const
|
|
{
|
|
return IsA( E::GetStaticTypeSymbol() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper for finding elements that refer to this element
|
|
//-----------------------------------------------------------------------------
|
|
template< class T >
|
|
T *FindReferringElement( CDmElement *pElement, const char *pAttrName, bool bMustBeInSameFile = true )
|
|
{
|
|
return FindReferringElement< T >( pElement, g_pDataModel->GetSymbol( pAttrName ), bMustBeInSameFile );
|
|
}
|
|
|
|
|
|
void RemoveElementFromRefereringAttributes( CDmElement *pElement, bool bPreserveOrder = true );
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// element-specific unique name generation methods
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// 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 = -1 );
|
|
|
|
bool GenerateUniqueName( char *name, int memsize, const char *prefix, const CUtlVector< DmElementHandle_t > &array );
|
|
|
|
void MakeElementNameUnique( CDmElement *pElement, const char *prefix, const CUtlVector< DmElementHandle_t > &array, bool forceIndex = false );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// helper for making attributevarelementarray cleanup easier
|
|
//-----------------------------------------------------------------------------
|
|
template< class T >
|
|
inline void CDmElement::DeleteAttributeVarElementArray( T &array )
|
|
{
|
|
int nElements = array.Count();
|
|
for ( int i = 0; i < nElements; ++i )
|
|
{
|
|
g_pDataModel->DestroyElement( array.GetHandle( i ) );
|
|
}
|
|
array.RemoveAll();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Default size computation
|
|
//-----------------------------------------------------------------------------
|
|
template< class T >
|
|
int DmeEstimateMemorySize( T* pElement )
|
|
{
|
|
return sizeof( T );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper macro to create an element; this is used for elements that are helper base classes
|
|
//-----------------------------------------------------------------------------
|
|
#define DEFINE_UNINSTANCEABLE_ELEMENT( className, baseClassName ) \
|
|
protected: \
|
|
className( DmElementHandle_t handle, const char *pElementTypeName, const DmObjectId_t &id, const char *pElementName, DmFileId_t fileid ) : \
|
|
baseClassName( handle, pElementTypeName, id, pElementName, fileid ) \
|
|
{ \
|
|
} \
|
|
virtual ~className() \
|
|
{ \
|
|
} \
|
|
void OnConstruction(); \
|
|
void OnDestruction(); \
|
|
virtual void PerformConstruction() \
|
|
{ \
|
|
BaseClass::PerformConstruction(); \
|
|
OnConstruction(); \
|
|
} \
|
|
virtual void PerformDestruction() \
|
|
{ \
|
|
OnDestruction(); \
|
|
BaseClass::PerformDestruction(); \
|
|
} \
|
|
virtual int AllocatedSize() const { return DmeEstimateMemorySize( this ); } \
|
|
\
|
|
private: \
|
|
typedef baseClassName BaseClass; \
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper macro to create the class factory
|
|
//-----------------------------------------------------------------------------
|
|
#define DEFINE_ELEMENT( className, baseClassName ) \
|
|
public: \
|
|
virtual bool IsA( UtlSymId_t typeSymbol ) const \
|
|
{ \
|
|
return IsA_Implementation( typeSymbol );\
|
|
} \
|
|
\
|
|
bool IsA( const char *pTypeName ) const \
|
|
{ \
|
|
CUtlSymbol typeSymbol = g_pDataModel->GetSymbol( pTypeName ); \
|
|
return IsA( typeSymbol ); \
|
|
} \
|
|
\
|
|
template< class T > bool IsA() const \
|
|
{ \
|
|
return IsA( T::GetStaticTypeSymbol() ); \
|
|
} \
|
|
\
|
|
virtual int GetInheritanceDepth( UtlSymId_t typeSymbol ) const \
|
|
{ \
|
|
return GetInheritanceDepth_Implementation( typeSymbol, 0 ); \
|
|
} \
|
|
\
|
|
static CUtlSymbol GetStaticTypeSymbol( ) \
|
|
{ \
|
|
return m_classType; \
|
|
} \
|
|
\
|
|
className* Copy( TraversalDepth_t depth = TD_DEEP ) const \
|
|
{ \
|
|
return static_cast< className* >( CopyInternal( depth ) ); \
|
|
} \
|
|
protected: \
|
|
className( DmElementHandle_t handle, const char *pElementTypeName, const DmObjectId_t &id, const char *pElementName, DmFileId_t fileid ) : \
|
|
baseClassName( handle, pElementTypeName, id, pElementName, fileid ) \
|
|
{ \
|
|
} \
|
|
virtual ~className() \
|
|
{ \
|
|
} \
|
|
void OnConstruction(); \
|
|
void OnDestruction(); \
|
|
virtual void PerformConstruction() \
|
|
{ \
|
|
BaseClass::PerformConstruction(); \
|
|
OnConstruction(); \
|
|
} \
|
|
virtual void PerformDestruction() \
|
|
{ \
|
|
OnDestruction(); \
|
|
BaseClass::PerformDestruction(); \
|
|
} \
|
|
static void SetTypeSymbol( CUtlSymbol typeSymbol ) \
|
|
{ \
|
|
m_classType = typeSymbol; \
|
|
} \
|
|
\
|
|
static bool IsA_Implementation( CUtlSymbol typeSymbol ) \
|
|
{ \
|
|
if ( typeSymbol == m_classType ) \
|
|
return true; \
|
|
return BaseClass::IsA_Implementation( typeSymbol ); \
|
|
} \
|
|
\
|
|
static int GetInheritanceDepth_Implementation( CUtlSymbol typeSymbol, int nCurrentDepth ) \
|
|
{ \
|
|
if ( typeSymbol == m_classType ) \
|
|
return nCurrentDepth; \
|
|
return BaseClass::GetInheritanceDepth_Implementation( typeSymbol, nCurrentDepth+1 );\
|
|
} \
|
|
virtual int AllocatedSize() const { return DmeEstimateMemorySize( this ); } \
|
|
\
|
|
private: \
|
|
typedef baseClassName BaseClass; \
|
|
template <class T> friend class CDmElementFactory; \
|
|
template <class T> friend class CDmAbstractElementFactory; \
|
|
static CUtlSymbol m_classType
|
|
|
|
#define IMPLEMENT_ELEMENT( className ) \
|
|
CUtlSymbol className::m_classType = UTL_INVAL_SYMBOL;
|
|
|
|
|
|
#endif // DMELEMENT_H
|