769 lines
23 KiB
C++
769 lines
23 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef DMATTRIBUTE_H
|
|
#define DMATTRIBUTE_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "datamodel/attributeflags.h"
|
|
#include "datamodel/idatamodel.h"
|
|
#include "datamodel/dmattributetypes.h"
|
|
#include "datamodel/dmelement.h"
|
|
#include "datamodel/dmvar.h"
|
|
#include "tier1/utlhash.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Fast dynamic cast
|
|
//-----------------------------------------------------------------------------
|
|
template< class E >
|
|
inline E *CastElement( CDmElement *pElement )
|
|
{
|
|
if ( pElement && pElement->IsA( E::GetStaticTypeSymbol() ) )
|
|
return static_cast< E* >( pElement );
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// type-safe element creation and accessor helpers - infers type name string from actual type
|
|
//-----------------------------------------------------------------------------
|
|
template< class E >
|
|
inline E *GetElement( DmElementHandle_t hElement )
|
|
{
|
|
CDmElement *pElement = g_pDataModel->GetElement( hElement );
|
|
return CastElement< E >( pElement );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Typesafe element creation + destruction
|
|
//-----------------------------------------------------------------------------
|
|
template< class E >
|
|
inline E *CreateElement( const char *pObjectName, DmFileId_t fileid = DMFILEID_INVALID, const DmObjectId_t *pObjectID = NULL )
|
|
{
|
|
return GetElement< E >( g_pDataModel->CreateElement( E::GetStaticTypeSymbol(), pObjectName, fileid, pObjectID ) );
|
|
}
|
|
|
|
template< class E >
|
|
inline E *CreateElement( const char *pElementType, const char *pObjectName, DmFileId_t fileid = DMFILEID_INVALID, const DmObjectId_t *pObjectID = NULL )
|
|
{
|
|
return GetElement< E >( g_pDataModel->CreateElement( pElementType, pObjectName, fileid, pObjectID ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used for attribute change callbacks
|
|
//-----------------------------------------------------------------------------
|
|
typedef unsigned short DmMailingList_t;
|
|
enum
|
|
{
|
|
DMMAILINGLIST_INVALID = (DmMailingList_t)~0
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: A general purpose pAttribute. Eventually will be extensible to arbitrary user types
|
|
//-----------------------------------------------------------------------------
|
|
class CDmAttribute
|
|
{
|
|
public:
|
|
// Returns the type
|
|
DmAttributeType_t GetType() const;
|
|
const char *GetTypeString() const;
|
|
template< class T > bool IsA() const;
|
|
|
|
// Returns the name. NOTE: The utlsymbol
|
|
// can be turned into a string by using g_pDataModel->String();
|
|
const char *GetName() const;
|
|
UtlSymId_t GetNameSymbol() const;
|
|
void SetName( const char *newName );
|
|
|
|
// Gets the attribute value
|
|
// NOTE: GetValueUntyped is used with GetType() for use w/ SetValue( type, void* )
|
|
template< class T > const T& GetValue() const;
|
|
template< class T > const T& GetValue( const T& defaultValue ) const;
|
|
const char *GetValueString() const;
|
|
template< class E > E *GetValueElement() const;
|
|
const void *GetValueUntyped() const;
|
|
|
|
// Sets the attribute value
|
|
template< class T > void SetValue( const T &value );
|
|
template< class E > void SetValue( E* pValue );
|
|
void SetValue( const void *pValue, size_t nSize );
|
|
|
|
// Copies w/ type conversion (if possible) from another attribute
|
|
void SetValue( const CDmAttribute *pAttribute );
|
|
void SetValue( CDmAttribute *pAttribute );
|
|
void SetValue( DmAttributeType_t valueType, const void *pValue );
|
|
|
|
// Sets the attribute to its default value based on its type
|
|
void SetToDefaultValue();
|
|
|
|
// Convert to and from string
|
|
void SetValueFromString( const char *pValue );
|
|
const char *GetValueAsString( char *pBuffer, size_t nBufLen ) const;
|
|
|
|
// Used for element and element array attributes; it specifies which type of
|
|
// elements are valid to be referred to by this attribute
|
|
void SetElementTypeSymbol( UtlSymId_t typeSymbol );
|
|
UtlSymId_t GetElementTypeSymbol() const;
|
|
|
|
// Returns the next attribute
|
|
CDmAttribute *NextAttribute();
|
|
const CDmAttribute *NextAttribute() const;
|
|
|
|
// Returns the owner
|
|
CDmElement *GetOwner();
|
|
|
|
// Methods related to flags
|
|
void AddFlag( int flags );
|
|
void RemoveFlag( int flags );
|
|
void ClearFlags();
|
|
int GetFlags() const;
|
|
bool IsFlagSet( int flags ) const;
|
|
|
|
// Serialization
|
|
bool Serialize( CUtlBuffer &buf ) const;
|
|
bool Unserialize( CUtlBuffer &buf );
|
|
|
|
// Serialization of a single element.
|
|
// First version of UnserializeElement adds to tail if it worked
|
|
// Second version overwrites, but does not add, the element at the specified index
|
|
bool SerializeElement( int nElement, CUtlBuffer &buf ) const;
|
|
bool UnserializeElement( CUtlBuffer &buf );
|
|
bool UnserializeElement( int nElement, CUtlBuffer &buf );
|
|
|
|
// Does this attribute serialize on multiple lines?
|
|
bool SerializesOnMultipleLines() const;
|
|
|
|
// Get the attribute/create an attribute handle
|
|
DmAttributeHandle_t GetHandle( bool bCreate = true );
|
|
|
|
// Notify external elements upon change ( Calls OnAttributeChanged )
|
|
// Pass false here to stop notification
|
|
void NotifyWhenChanged( DmElementHandle_t h, bool bNotify );
|
|
|
|
// estimate memory overhead
|
|
int EstimateMemoryUsage( TraversalDepth_t depth ) const;
|
|
|
|
private:
|
|
// Class factory
|
|
static CDmAttribute *CreateAttribute( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName );
|
|
static CDmAttribute *CreateExternalAttribute( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName, void *pExternalMemory );
|
|
static void DestroyAttribute( CDmAttribute *pAttribute );
|
|
|
|
// Constructor, destructor
|
|
CDmAttribute( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName );
|
|
CDmAttribute( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName, void *pMemory );
|
|
~CDmAttribute();
|
|
|
|
// Used when constructing CDmAttributes
|
|
void Init( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName );
|
|
|
|
// Used when shutting down, indicates DmAttributeHandle_t referring to this are invalid
|
|
void InvalidateHandle();
|
|
|
|
// Used when shutting down, indicates no more change notifications will be sent to listening elements
|
|
void CleanupMailingList();
|
|
|
|
// Called when the attribute changes
|
|
void PreChanged();
|
|
void OnChanged( bool bArrayCountChanged = false, bool bIsTopological = false );
|
|
|
|
// Is modification allowed in this phase?
|
|
bool ModificationAllowed() const;
|
|
|
|
// Mark the attribute as being dirty
|
|
bool MarkDirty();
|
|
|
|
// Is the data inline in a containing element class?
|
|
bool IsDataInline() const;
|
|
|
|
// Allocates, frees internal data storage
|
|
void CreateAttributeData();
|
|
void DeleteAttributeData();
|
|
|
|
// Gets at the internal data storage
|
|
void* GetAttributeData();
|
|
const void* GetAttributeData() const;
|
|
template < class T > typename CDmAttributeInfo< T >::StorageType_t* GetData();
|
|
template < class T > const typename CDmAttributeInfo< T >::StorageType_t* GetData() const;
|
|
template < class T > typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* GetArrayData();
|
|
template < class T > const typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* GetArrayData() const;
|
|
|
|
// Used by CDmElement to manage the list of attributes it owns
|
|
CDmAttribute **GetNextAttributeRef();
|
|
|
|
// Implementational function used for memory consumption estimation computation
|
|
int EstimateMemoryUsageInternal( CUtlHash< DmElementHandle_t > &visited, TraversalDepth_t depth, int *pCategories ) const;
|
|
|
|
// Called by elements after unserialization of their attributes is complete
|
|
void OnUnserializationFinished();
|
|
|
|
template< class T > bool IsTypeConvertable() const;
|
|
template< class T > bool ShouldModify( const T& src );
|
|
template< class T > void CopyData( const T& src );
|
|
template< class T > void CopyDataOut( T& dest ) const;
|
|
|
|
private:
|
|
CDmAttribute *m_pNext;
|
|
void *m_pData;
|
|
CDmElement *m_pOwner;
|
|
int m_nFlags;
|
|
DmAttributeHandle_t m_Handle;
|
|
CUtlSymbol m_Name;
|
|
DmMailingList_t m_hMailingList;
|
|
|
|
friend class CDmElement;
|
|
friend class CDmAttributeAccessor;
|
|
template< class T > friend class CDmrElementArray;
|
|
template< class E > friend class CDmrElementArrayConst;
|
|
template< class T > friend class CDmaArrayAccessor;
|
|
template< class T, class B > friend class CDmrDecorator;
|
|
template< class T, class B > friend class CDmrDecoratorConst;
|
|
template< class T > friend class CDmArrayAttributeOp;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Inline methods
|
|
//-----------------------------------------------------------------------------
|
|
inline DmAttributeType_t CDmAttribute::GetType() const
|
|
{
|
|
return (DmAttributeType_t)( m_nFlags & FATTRIB_TYPEMASK );
|
|
}
|
|
|
|
template< class T > inline bool CDmAttribute::IsA() const
|
|
{
|
|
return GetType() == CDmAttributeInfo< T >::AttributeType();
|
|
}
|
|
|
|
inline const char *CDmAttribute::GetName() const
|
|
{
|
|
return g_pDataModel->GetString( m_Name );
|
|
}
|
|
|
|
inline UtlSymId_t CDmAttribute::GetNameSymbol() const
|
|
{
|
|
return m_Name;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Iteration
|
|
//-----------------------------------------------------------------------------
|
|
inline CDmAttribute *CDmAttribute::NextAttribute()
|
|
{
|
|
return m_pNext;
|
|
}
|
|
|
|
inline const CDmAttribute *CDmAttribute::NextAttribute() const
|
|
{
|
|
return m_pNext;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the owner
|
|
//-----------------------------------------------------------------------------
|
|
inline CDmElement *CDmAttribute::GetOwner()
|
|
{
|
|
return m_pOwner;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Value getting methods
|
|
//-----------------------------------------------------------------------------
|
|
template< class T >
|
|
inline const T& CDmAttribute::GetValue( const T& defaultValue ) const
|
|
{
|
|
if ( GetType() == ( DmAttributeType_t )( CDmAttributeInfo< T >::ATTRIBUTE_TYPE ) )
|
|
return *reinterpret_cast< const T* >( m_pData );
|
|
|
|
if ( IsTypeConvertable< T >() )
|
|
{
|
|
static T tempVal;
|
|
CopyDataOut( tempVal );
|
|
return tempVal;
|
|
}
|
|
|
|
Assert( 0 );
|
|
return defaultValue;
|
|
}
|
|
|
|
template< class T >
|
|
inline const T& CDmAttribute::GetValue() const
|
|
{
|
|
static CDmaVar< T > defaultVal;
|
|
return GetValue( defaultVal.Get() );
|
|
}
|
|
|
|
inline const char *CDmAttribute::GetValueString() const
|
|
{
|
|
Assert( GetType() == AT_STRING );
|
|
if ( GetType() != AT_STRING )
|
|
return NULL;
|
|
|
|
return GetValue< CUtlString >();
|
|
}
|
|
|
|
// used with GetType() for use w/ SetValue( type, void* )
|
|
inline const void* CDmAttribute::GetValueUntyped() const
|
|
{
|
|
return m_pData;
|
|
}
|
|
|
|
template< class E >
|
|
inline E* CDmAttribute::GetValueElement() const
|
|
{
|
|
Assert( GetType() == AT_ELEMENT );
|
|
if ( GetType() == AT_ELEMENT )
|
|
return GetElement<E>( this->GetValue< DmElementHandle_t >() );
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Value setting methods
|
|
//-----------------------------------------------------------------------------
|
|
template< class E >
|
|
inline void CDmAttribute::SetValue( E* pValue )
|
|
{
|
|
Assert( GetType() == AT_ELEMENT );
|
|
if ( GetType() == AT_ELEMENT )
|
|
{
|
|
SetValue( pValue ? pValue->GetHandle() : DMELEMENT_HANDLE_INVALID );
|
|
}
|
|
}
|
|
|
|
template<>
|
|
inline void CDmAttribute::SetValue( const char *pValue )
|
|
{
|
|
int nLen = pValue ? Q_strlen( pValue ) + 1 : 0;
|
|
CUtlString str( pValue, nLen );
|
|
return SetValue( str );
|
|
}
|
|
|
|
template<>
|
|
inline void CDmAttribute::SetValue( char *pValue )
|
|
{
|
|
return SetValue( (const char *)pValue );
|
|
}
|
|
|
|
inline void CDmAttribute::SetValue( const void *pValue, size_t nSize )
|
|
{
|
|
CUtlBinaryBlock buf( pValue, (int)nSize );
|
|
return SetValue( buf );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Methods related to flags
|
|
//-----------------------------------------------------------------------------
|
|
inline void CDmAttribute::AddFlag( int nFlags )
|
|
{
|
|
m_nFlags |= nFlags;
|
|
}
|
|
|
|
inline void CDmAttribute::RemoveFlag( int nFlags )
|
|
{
|
|
m_nFlags &= ~nFlags;
|
|
}
|
|
|
|
inline void CDmAttribute::ClearFlags()
|
|
{
|
|
m_nFlags = 0;
|
|
}
|
|
|
|
inline int CDmAttribute::GetFlags() const
|
|
{
|
|
return m_nFlags;
|
|
}
|
|
|
|
inline bool CDmAttribute::IsFlagSet( int nFlags ) const
|
|
{
|
|
return ( nFlags & m_nFlags ) ? true : false;
|
|
}
|
|
|
|
inline bool CDmAttribute::IsDataInline() const
|
|
{
|
|
return !IsFlagSet(FATTRIB_EXTERNAL);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets at the internal data storage
|
|
//-----------------------------------------------------------------------------
|
|
inline void* CDmAttribute::GetAttributeData()
|
|
{
|
|
return m_pData;
|
|
}
|
|
|
|
inline const void* CDmAttribute::GetAttributeData() const
|
|
{
|
|
return m_pData;
|
|
}
|
|
|
|
template < class T >
|
|
inline typename CDmAttributeInfo< T >::StorageType_t* CDmAttribute::GetData()
|
|
{
|
|
return ( typename CDmAttributeInfo< T >::StorageType_t* )m_pData;
|
|
}
|
|
|
|
template < class T >
|
|
inline typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* CDmAttribute::GetArrayData()
|
|
{
|
|
return ( typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* )m_pData;
|
|
}
|
|
|
|
template < class T >
|
|
inline const typename CDmAttributeInfo< T >::StorageType_t* CDmAttribute::GetData() const
|
|
{
|
|
return ( const typename CDmAttributeInfo< T >::StorageType_t* )m_pData;
|
|
}
|
|
|
|
template < class T >
|
|
inline const typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* CDmAttribute::GetArrayData() const
|
|
{
|
|
return ( const typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* )m_pData;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used by CDmElement to manage the list of attributes it owns
|
|
//-----------------------------------------------------------------------------
|
|
inline CDmAttribute **CDmAttribute::GetNextAttributeRef()
|
|
{
|
|
return &m_pNext;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// helper function for determining which attributes/elements to traverse during copy/find/save/etc.
|
|
//-----------------------------------------------------------------------------
|
|
inline bool ShouldTraverse( const CDmAttribute *pAttr, TraversalDepth_t depth )
|
|
{
|
|
switch ( depth )
|
|
{
|
|
case TD_NONE:
|
|
return false;
|
|
|
|
case TD_SHALLOW:
|
|
if ( !pAttr->IsFlagSet( FATTRIB_MUSTCOPY ) )
|
|
return false;
|
|
// fall-through intentional
|
|
case TD_DEEP:
|
|
if ( pAttr->IsFlagSet( FATTRIB_NEVERCOPY ) )
|
|
return false;
|
|
// fall-through intentional
|
|
case TD_ALL:
|
|
return true;
|
|
}
|
|
|
|
Assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets attributes
|
|
//-----------------------------------------------------------------------------
|
|
inline CDmAttribute *CDmElement::GetAttribute( const char *pAttributeName, DmAttributeType_t type )
|
|
{
|
|
CDmAttribute *pAttribute = FindAttribute( pAttributeName );
|
|
if ( ( type != AT_UNKNOWN ) && pAttribute && ( pAttribute->GetType() != type ) )
|
|
return NULL;
|
|
return pAttribute;
|
|
}
|
|
|
|
inline const CDmAttribute *CDmElement::GetAttribute( const char *pAttributeName, DmAttributeType_t type ) const
|
|
{
|
|
CDmAttribute *pAttribute = FindAttribute( pAttributeName );
|
|
if ( ( type != AT_UNKNOWN ) && pAttribute && ( pAttribute->GetType() != type ) )
|
|
return NULL;
|
|
return pAttribute;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// AddAttribute calls
|
|
//-----------------------------------------------------------------------------
|
|
inline CDmAttribute *CDmElement::AddAttribute( const char *pAttributeName, DmAttributeType_t type )
|
|
{
|
|
CDmAttribute *pAttribute = FindAttribute( pAttributeName );
|
|
if ( pAttribute )
|
|
return ( pAttribute->GetType() == type ) ? pAttribute : NULL;
|
|
pAttribute = CreateAttribute( pAttributeName, type );
|
|
return pAttribute;
|
|
}
|
|
|
|
template< class E > inline CDmAttribute *CDmElement::AddAttributeElement( const char *pAttributeName )
|
|
{
|
|
CDmAttribute *pAttribute = AddAttribute( pAttributeName, AT_ELEMENT );
|
|
if ( !pAttribute )
|
|
return NULL;
|
|
|
|
// FIXME: If the attribute exists but has a different element type symbol, should we complain?
|
|
pAttribute->SetElementTypeSymbol( E::GetStaticTypeSymbol() );
|
|
return pAttribute;
|
|
}
|
|
|
|
template< class E > inline CDmAttribute *CDmElement::AddAttributeElementArray( const char *pAttributeName )
|
|
{
|
|
CDmAttribute *pAttribute = AddAttribute( pAttributeName, AT_ELEMENT_ARRAY );
|
|
if ( !pAttribute )
|
|
return NULL;
|
|
|
|
// FIXME: If the attribute exists but has a different element type symbol, should we complain?
|
|
pAttribute->SetElementTypeSymbol( E::GetStaticTypeSymbol() );
|
|
return pAttribute;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// GetValue methods
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template< class T >
|
|
inline const T& CDmElement::GetValue( const char *pAttributeName ) const
|
|
{
|
|
static CDmaVar<T> defaultVal;
|
|
return GetValue( pAttributeName, defaultVal.Get() );
|
|
}
|
|
|
|
inline const char *CDmElement::GetValueString( const char *pAttributeName ) const
|
|
{
|
|
return GetValue<CUtlString>( pAttributeName ).Get();
|
|
}
|
|
|
|
template< class E >
|
|
inline E* CDmElement::GetValueElement( const char *pAttributeName ) const
|
|
{
|
|
DmElementHandle_t h = GetValue< DmElementHandle_t >( pAttributeName );
|
|
return GetElement<E>( h );
|
|
}
|
|
|
|
|
|
template< class T >
|
|
inline const T& CDmElement::GetValue( const char *pAttributeName, const T& defaultVal ) const
|
|
{
|
|
const CDmAttribute *pAttribute = FindAttribute( pAttributeName );
|
|
if ( pAttribute != NULL )
|
|
return pAttribute->GetValue<T>();
|
|
return defaultVal;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SetValue methods
|
|
//-----------------------------------------------------------------------------
|
|
template< class T >
|
|
inline CDmAttribute* CDmElement::SetValue( const char *pAttributeName, const T& value )
|
|
{
|
|
CDmAttribute *pAttribute = FindAttribute( pAttributeName );
|
|
if ( !pAttribute )
|
|
{
|
|
pAttribute = CreateAttribute( pAttributeName, CDmAttributeInfo<T>::AttributeType() );
|
|
}
|
|
if ( pAttribute )
|
|
{
|
|
pAttribute->SetValue( value );
|
|
return pAttribute;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
template< class E >
|
|
inline CDmAttribute* CDmElement::SetValue( const char *pAttributeName, E* pElement )
|
|
{
|
|
DmElementHandle_t hElement = pElement ? pElement->GetHandle() : DMELEMENT_HANDLE_INVALID;
|
|
return SetValue( pAttributeName, hElement );
|
|
}
|
|
|
|
template<>
|
|
inline CDmAttribute* CDmElement::SetValue( const char *pAttributeName, const char *pValue )
|
|
{
|
|
int nLen = pValue ? Q_strlen( pValue ) + 1 : 0;
|
|
CUtlString str( pValue, nLen );
|
|
return SetValue( pAttributeName, str );
|
|
}
|
|
|
|
template<>
|
|
inline CDmAttribute* CDmElement::SetValue( const char *pAttributeName, char *pValue )
|
|
{
|
|
return SetValue( pAttributeName, (const char *)pValue );
|
|
}
|
|
|
|
inline CDmAttribute* CDmElement::SetValue( const char *pAttributeName, const void *pValue, size_t nSize )
|
|
{
|
|
CUtlBinaryBlock buf( pValue, (int)nSize );
|
|
return SetValue( pAttributeName, buf );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// AddValue methods( set value if not found )
|
|
//-----------------------------------------------------------------------------
|
|
template< class T >
|
|
inline CDmAttribute* CDmElement::InitValue( const char *pAttributeName, const T& value )
|
|
{
|
|
CDmAttribute *pAttribute = GetAttribute( pAttributeName );
|
|
if ( !pAttribute )
|
|
return SetValue( pAttributeName, value );
|
|
return pAttribute;
|
|
}
|
|
|
|
template< class E >
|
|
inline CDmAttribute* CDmElement::InitValue( const char *pAttributeName, E* pElement )
|
|
{
|
|
DmElementHandle_t hElement = pElement ? pElement->GetHandle() : DMELEMENT_HANDLE_INVALID;
|
|
return InitValue( pAttributeName, hElement );
|
|
}
|
|
|
|
inline CDmAttribute* CDmElement::InitValue( const char *pAttributeName, const void *pValue, size_t size )
|
|
{
|
|
CDmAttribute *pAttribute = GetAttribute( pAttributeName );
|
|
if ( !pAttribute )
|
|
return SetValue( pAttributeName, pValue, size );
|
|
return pAttribute;
|
|
}
|
|
|
|
template< class T >
|
|
T *FindReferringElement( CDmElement *pElement, UtlSymId_t symAttrName, bool bMustBeInSameFile = true )
|
|
{
|
|
DmAttributeReferenceIterator_t i = g_pDataModel->FirstAttributeReferencingElement( pElement->GetHandle() );
|
|
while ( i != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID )
|
|
{
|
|
CDmAttribute *pAttribute = g_pDataModel->GetAttribute( i );
|
|
CDmElement *pDmeParent = pAttribute->GetOwner();
|
|
if ( pDmeParent && pAttribute->GetNameSymbol() == symAttrName )
|
|
{
|
|
T *pParent = CastElement< T >( pDmeParent );
|
|
if ( pParent )
|
|
{
|
|
if ( !bMustBeInSameFile || ( pParent->GetFileId() == pElement->GetFileId() ) )
|
|
return pParent;
|
|
}
|
|
}
|
|
i = g_pDataModel->NextAttributeReferencingElement( i );
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
template< class T >
|
|
T *FindAncestorReferencingElement( CDmElement *target )
|
|
{
|
|
if ( !target )
|
|
return NULL;
|
|
|
|
for ( DmAttributeReferenceIterator_t it = g_pDataModel->FirstAttributeReferencingElement( target->GetHandle() );
|
|
it != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
|
|
it = g_pDataModel->NextAttributeReferencingElement( it ) )
|
|
{
|
|
CDmAttribute *attr = g_pDataModel->GetAttribute( it );
|
|
Assert( attr );
|
|
CDmElement *element = attr->GetOwner();
|
|
Assert( element );
|
|
if ( !element )
|
|
continue;
|
|
T *t = CastElement< T >( element );
|
|
if ( !t )
|
|
continue;
|
|
|
|
return t;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
template< class T >
|
|
T *FindAncestorReferencingElement_R_Impl( CUtlRBTree< CDmElement * >& visited, CDmElement *check )
|
|
{
|
|
if ( visited.Find( check ) != visited.InvalidIndex() )
|
|
return NULL;
|
|
|
|
visited.Insert( check );
|
|
|
|
// Pass one, see if it's in this ancestor list
|
|
DmAttributeReferenceIterator_t it;
|
|
for ( it = g_pDataModel->FirstAttributeReferencingElement( check->GetHandle() );
|
|
it != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
|
|
it = g_pDataModel->NextAttributeReferencingElement( it ) )
|
|
{
|
|
CDmAttribute *attr = g_pDataModel->GetAttribute( it );
|
|
Assert( attr );
|
|
CDmElement *element = attr->GetOwner();
|
|
Assert( element );
|
|
if ( !element )
|
|
continue;
|
|
T *t = CastElement< T >( element );
|
|
if ( !t )
|
|
continue;
|
|
|
|
return t;
|
|
}
|
|
|
|
for ( it = g_pDataModel->FirstAttributeReferencingElement( check->GetHandle() );
|
|
it != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
|
|
it = g_pDataModel->NextAttributeReferencingElement( it ) )
|
|
{
|
|
CDmAttribute *attr = g_pDataModel->GetAttribute( it );
|
|
Assert( attr );
|
|
CDmElement *element = attr->GetOwner();
|
|
Assert( element );
|
|
if ( !element )
|
|
continue;
|
|
|
|
T *found = FindAncestorReferencingElement_R_Impl< T >( visited, element );
|
|
if ( found )
|
|
return found;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
template< class T >
|
|
void FindAncestorsReferencingElement( CDmElement *target, CUtlVector< T* >& list )
|
|
{
|
|
if ( !target )
|
|
return;
|
|
|
|
list.RemoveAll();
|
|
for ( DmAttributeReferenceIterator_t it = g_pDataModel->FirstAttributeReferencingElement( target->GetHandle() );
|
|
it != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
|
|
it = g_pDataModel->NextAttributeReferencingElement( it ) )
|
|
{
|
|
CDmAttribute *attr = g_pDataModel->GetAttribute( it );
|
|
Assert( attr );
|
|
CDmElement *element = attr->GetOwner();
|
|
Assert( element );
|
|
if ( !element )
|
|
continue;
|
|
T* t = CastElement< T >( element );
|
|
if ( !t )
|
|
continue;
|
|
|
|
if ( list.Find( t ) != list.InvalidIndex() )
|
|
continue;
|
|
|
|
list.AddToTail( t );
|
|
}
|
|
}
|
|
|
|
|
|
template< class T >
|
|
T *FindAncestorReferencingElement_R( CDmElement *target )
|
|
{
|
|
if ( !target )
|
|
return NULL;
|
|
|
|
CUtlRBTree< CDmElement * > visited( 0, 0, DefLessFunc( CDmElement * ) );
|
|
return FindAncestorReferencingElement_R_Impl< T >( visited, target );
|
|
}
|
|
|
|
|
|
#endif // DMATTRIBUTE_H
|