dmxattribute.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================

#include "dmxloader/dmxattribute.h"
#include "tier1/utlbufferutil.h"
#include "tier1/uniqueid.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"


//-----------------------------------------------------------------------------
// globals
//-----------------------------------------------------------------------------
CUtlSymbolTableMT CDmxAttribute::s_AttributeNameSymbols;


//-----------------------------------------------------------------------------
// Attribute size
//-----------------------------------------------------------------------------
static size_t s_pAttributeSize[AT_TYPE_COUNT] = 
{
	0,							// AT_UNKNOWN,
	sizeof(CDmxElement*),		// AT_ELEMENT,
	sizeof(int),				// AT_INT,
	sizeof(float),				// AT_FLOAT,
	sizeof(bool),				// AT_BOOL,
	sizeof(CUtlString),			// AT_STRING,
	sizeof(CUtlBinaryBlock),	// AT_VOID,
	sizeof(DmObjectId_t),		// AT_OBJECTID,
	sizeof(Color),				// AT_COLOR,
	sizeof(Vector2D),			// AT_VECTOR2,
	sizeof(Vector),				// AT_VECTOR3,
	sizeof(Vector4D),			// AT_VECTOR4,
	sizeof(QAngle),				// AT_QANGLE,
	sizeof(Quaternion),			// AT_QUATERNION,
	sizeof(VMatrix),			// AT_VMATRIX,
	sizeof(CUtlVector<CDmxElement*>),		// AT_ELEMENT_ARRAY,
	sizeof(CUtlVector<int>),				// AT_INT_ARRAY,
	sizeof(CUtlVector<float>),				// AT_FLOAT_ARRAY,
	sizeof(CUtlVector<bool>),				// AT_BOOL_ARRAY,
	sizeof(CUtlVector<CUtlString>),			// AT_STRING_ARRAY,
	sizeof(CUtlVector<CUtlBinaryBlock>),	// AT_VOID_ARRAY,
	sizeof(CUtlVector<DmObjectId_t>),		// AT_OBJECTID_ARRAY,
	sizeof(CUtlVector<Color>),				// AT_COLOR_ARRAY,
	sizeof(CUtlVector<Vector2D>),			// AT_VECTOR2_ARRAY,
	sizeof(CUtlVector<Vector>),				// AT_VECTOR3_ARRAY,
	sizeof(CUtlVector<Vector4D>),			// AT_VECTOR4_ARRAY,
	sizeof(CUtlVector<QAngle>),				// AT_QANGLE_ARRAY,
	sizeof(CUtlVector<Quaternion>),			// AT_QUATERNION_ARRAY,
	sizeof(CUtlVector<VMatrix>),			// AT_VMATRIX_ARRAY,
};


//-----------------------------------------------------------------------------
// make sure that the attribute data type sizes are what we think they are to choose the right allocator
//-----------------------------------------------------------------------------
struct CSizeTest
{
	CSizeTest()
	{
		// test internal value attribute sizes
		COMPILE_TIME_ASSERT( sizeof( int )			== 4 );
		COMPILE_TIME_ASSERT( sizeof( float )		== 4 );
		COMPILE_TIME_ASSERT( sizeof( bool )			<= 4 );
		COMPILE_TIME_ASSERT( sizeof( Color )		== 4 );
		COMPILE_TIME_ASSERT( sizeof( Vector2D )		== 8 );
		COMPILE_TIME_ASSERT( sizeof( Vector )		== 12 );
		COMPILE_TIME_ASSERT( sizeof( Vector4D )		== 16 );
		COMPILE_TIME_ASSERT( sizeof( QAngle )		== 12 );
		COMPILE_TIME_ASSERT( sizeof( Quaternion )	== 16 );
		COMPILE_TIME_ASSERT( sizeof( VMatrix )		== 64 );
#if !defined( PLATFORM_64BITS )
		COMPILE_TIME_ASSERT( sizeof( CUtlString )	== 4 );
		COMPILE_TIME_ASSERT( sizeof( CUtlBinaryBlock ) == 16 );
#endif
		COMPILE_TIME_ASSERT( sizeof( DmObjectId_t )	== 16 );
	};
};
static CSizeTest g_sizeTest;


//-----------------------------------------------------------------------------
// Returns attribute name for type
//-----------------------------------------------------------------------------
const char *g_pAttributeTypeName[AT_TYPE_COUNT] = 
{
	"unknown", // AT_UNKNOWN
	CDmAttributeInfo<DmElementHandle_t>::AttributeTypeName(), // AT_ELEMENT,
	CDmAttributeInfo<int>::AttributeTypeName(), // AT_INT,
	CDmAttributeInfo<float>::AttributeTypeName(), // AT_FLOAT,
	CDmAttributeInfo<bool>::AttributeTypeName(), // AT_BOOL,
	CDmAttributeInfo<CUtlString>::AttributeTypeName(), // AT_STRING,
	CDmAttributeInfo<CUtlBinaryBlock>::AttributeTypeName(), // AT_VOID,
	CDmAttributeInfo<DmObjectId_t>::AttributeTypeName(), // AT_OBJECTID,
	CDmAttributeInfo<Color>::AttributeTypeName(), // AT_COLOR,
	CDmAttributeInfo<Vector2D>::AttributeTypeName(), // AT_VECTOR2,
	CDmAttributeInfo<Vector>::AttributeTypeName(), // AT_VECTOR3,
	CDmAttributeInfo<Vector4D>::AttributeTypeName(), // AT_VECTOR4,
	CDmAttributeInfo<QAngle>::AttributeTypeName(), // AT_QANGLE,
	CDmAttributeInfo<Quaternion>::AttributeTypeName(), // AT_QUATERNION,
	CDmAttributeInfo<VMatrix>::AttributeTypeName(), // AT_VMATRIX,
	CDmAttributeInfo< CUtlVector< DmElementHandle_t > >::AttributeTypeName(), // AT_ELEMENT_ARRAY,
	CDmAttributeInfo< CUtlVector< int > >::AttributeTypeName(), // AT_INT_ARRAY,
	CDmAttributeInfo< CUtlVector< float > >::AttributeTypeName(), // AT_FLOAT_ARRAY,
	CDmAttributeInfo< CUtlVector< bool > >::AttributeTypeName(), // AT_BOOL_ARRAY,
	CDmAttributeInfo< CUtlVector< CUtlString > >::AttributeTypeName(), // AT_STRING_ARRAY,
	CDmAttributeInfo< CUtlVector< CUtlBinaryBlock > >::AttributeTypeName(), // AT_VOID_ARRAY,
	CDmAttributeInfo< CUtlVector< DmObjectId_t > >::AttributeTypeName(), // AT_OBJECTID_ARRAY,
	CDmAttributeInfo< CUtlVector< Color > >::AttributeTypeName(), // AT_COLOR_ARRAY,
	CDmAttributeInfo< CUtlVector< Vector2D > >::AttributeTypeName(), // AT_VECTOR2_ARRAY,
	CDmAttributeInfo< CUtlVector< Vector > >::AttributeTypeName(), // AT_VECTOR3_ARRAY,
	CDmAttributeInfo< CUtlVector< Vector4D > >::AttributeTypeName(), // AT_VECTOR4_ARRAY,
	CDmAttributeInfo< CUtlVector< QAngle > >::AttributeTypeName(), // AT_QANGLE_ARRAY,
	CDmAttributeInfo< CUtlVector< Quaternion > >::AttributeTypeName(), // AT_QUATERNION_ARRAY,
	CDmAttributeInfo< CUtlVector< VMatrix > >::AttributeTypeName(), // AT_VMATRIX_ARRAY,
};


//-----------------------------------------------------------------------------
// Constructor, destructor 
//-----------------------------------------------------------------------------
CDmxAttribute::CDmxAttribute( const char *pAttributeName )
{
	m_Name = s_AttributeNameSymbols.AddString( pAttributeName );
	m_Type = AT_UNKNOWN;
	m_pData = NULL;
}

CDmxAttribute::CDmxAttribute( CUtlSymbol attributeName )
{
	m_Name = attributeName;
	m_Type = AT_UNKNOWN;
	m_pData = NULL;
}

CDmxAttribute::~CDmxAttribute()
{
	FreeDataMemory();
}


//-----------------------------------------------------------------------------
// Returns the size of the variables storing the various attribute types
//-----------------------------------------------------------------------------
int CDmxAttribute::AttributeDataSize( DmAttributeType_t type )
{
	return s_pAttributeSize[type];
}


//-----------------------------------------------------------------------------
// Allocate, free memory for data
//-----------------------------------------------------------------------------
void CDmxAttribute::AllocateDataMemory( DmAttributeType_t type )
{
	FreeDataMemory();

	m_Type = type;
	m_pData = DMXAlloc( s_pAttributeSize[m_Type] );
}

#define DESTRUCT_ARRAY( _dataType )									\
case CDmAttributeInfo< CUtlVector< _dataType > >::ATTRIBUTE_TYPE:	\
	Destruct( ( CUtlVector< _dataType >* )m_pData );				\
	break;

void CDmxAttribute::FreeDataMemory()
{
	if ( m_Type != AT_UNKNOWN )
	{
		Assert( m_pData != NULL );
		if ( !IsArrayType( m_Type ) )
		{
			if ( m_Type == AT_STRING )
			{
				Destruct( (CUtlString*)m_pData );
			}
			else if ( m_Type == AT_VOID	)
			{
				Destruct( (CUtlBinaryBlock*)m_pData );
			}
		}
		else
		{
			switch ( m_Type )
			{
				DESTRUCT_ARRAY( int );
				DESTRUCT_ARRAY( float );
				DESTRUCT_ARRAY( bool );
				DESTRUCT_ARRAY( CUtlString );
				DESTRUCT_ARRAY( CUtlBinaryBlock );
				DESTRUCT_ARRAY( DmObjectId_t );
				DESTRUCT_ARRAY( Color );
				DESTRUCT_ARRAY( Vector2D );
				DESTRUCT_ARRAY( Vector );
				DESTRUCT_ARRAY( Vector4D );
				DESTRUCT_ARRAY( QAngle );
				DESTRUCT_ARRAY( Quaternion );
				DESTRUCT_ARRAY( VMatrix );
				DESTRUCT_ARRAY( CDmxElement* );
			}
		}
		m_Type = AT_UNKNOWN;
	}
}


//-----------------------------------------------------------------------------
// Returns attribute type string
//-----------------------------------------------------------------------------
inline const char* CDmxAttribute::GetTypeString() const
{
	return g_pAttributeTypeName[ m_Type ];
}


//-----------------------------------------------------------------------------
// Returns attribute name
//-----------------------------------------------------------------------------
const char *CDmxAttribute::GetName() const
{
	return s_AttributeNameSymbols.String( m_Name );
}


//-----------------------------------------------------------------------------
// Gets the size of an array, returns 0 if it's not an array type
//-----------------------------------------------------------------------------
#define GET_ARRAY_COUNT( _dataType )			\
	case CDmAttributeInfo< CUtlVector< _dataType > >::ATTRIBUTE_TYPE:		\
	{															\
		const CUtlVector< _dataType > &array = *( CUtlVector< _dataType >* )m_pData; \
		return array.Count();									\
	}

int CDmxAttribute::GetArrayCount() const
{
	if ( !IsArrayType( m_Type ) || !m_pData )
		return 0;

	switch( m_Type )
	{
		GET_ARRAY_COUNT( int );
		GET_ARRAY_COUNT( float );
		GET_ARRAY_COUNT( bool );
		GET_ARRAY_COUNT( CUtlString );
		GET_ARRAY_COUNT( CUtlBinaryBlock );
		GET_ARRAY_COUNT( DmObjectId_t );
		GET_ARRAY_COUNT( Color );
		GET_ARRAY_COUNT( Vector2D );
		GET_ARRAY_COUNT( Vector );
		GET_ARRAY_COUNT( Vector4D );
		GET_ARRAY_COUNT( QAngle );
		GET_ARRAY_COUNT( Quaternion );
		GET_ARRAY_COUNT( VMatrix );
		GET_ARRAY_COUNT( CDmxElement* );
	}

	return 0;
}


//-----------------------------------------------------------------------------
// Gets the size of an array, returns 0 if it's not an array type
//-----------------------------------------------------------------------------
#define SERIALIZES_ON_MULTIPLE_LINES( _dataType )	\
	case CDmAttributeInfo< _dataType >::ATTRIBUTE_TYPE: \
		return ::SerializesOnMultipleLines< _dataType >();  \
	case CDmAttributeInfo< CUtlVector< _dataType > >::ATTRIBUTE_TYPE: \
		return ::SerializesOnMultipleLines< CUtlVector< _dataType > >()

bool CDmxAttribute::SerializesOnMultipleLines() const
{
	switch( m_Type )
	{
		SERIALIZES_ON_MULTIPLE_LINES( CDmxElement* );
		SERIALIZES_ON_MULTIPLE_LINES( int );
		SERIALIZES_ON_MULTIPLE_LINES( float );
		SERIALIZES_ON_MULTIPLE_LINES( bool );
		SERIALIZES_ON_MULTIPLE_LINES( CUtlString );
		SERIALIZES_ON_MULTIPLE_LINES( CUtlBinaryBlock );
		SERIALIZES_ON_MULTIPLE_LINES( DmObjectId_t );
		SERIALIZES_ON_MULTIPLE_LINES( Color );
		SERIALIZES_ON_MULTIPLE_LINES( Vector2D );
		SERIALIZES_ON_MULTIPLE_LINES( Vector );
		SERIALIZES_ON_MULTIPLE_LINES( Vector4D );
		SERIALIZES_ON_MULTIPLE_LINES( QAngle );
		SERIALIZES_ON_MULTIPLE_LINES( Quaternion );
		SERIALIZES_ON_MULTIPLE_LINES( VMatrix );
	}

	return false;
}


//-----------------------------------------------------------------------------
// Write to file
//-----------------------------------------------------------------------------
#define SERIALIZE_TYPE( _buf, _attributeType, _dataType )		\
	case _attributeType:										\
	{															\
		if ( m_pData )											\
			return ::Serialize( _buf, *(_dataType*)m_pData );	\
		_dataType temp;											\
		CDmAttributeInfo< _dataType >::SetDefaultValue( temp ); \
		return ::Serialize( _buf, temp );						\
	}

#define SERIALIZE_ARRAY_TYPE( _buf, _attributeType, _dataType )	\
	case _attributeType:										\
	{															\
		if ( m_pData )											\
			return ::Serialize( _buf, *(CUtlVector< _dataType >*)m_pData ); \
		CUtlVector< _dataType > temp;							\
		CDmAttributeInfo< CUtlVector< _dataType > >::SetDefaultValue( temp ); \
		return ::Serialize( _buf, temp );						\
	}

bool CDmxAttribute::Serialize( CUtlBuffer &buf ) const
{
	switch( m_Type )
	{
		SERIALIZE_TYPE( buf, AT_INT, int );
		SERIALIZE_TYPE( buf, AT_FLOAT, float );
		SERIALIZE_TYPE( buf, AT_BOOL, bool );
		SERIALIZE_TYPE( buf, AT_STRING, CUtlString );
		SERIALIZE_TYPE( buf, AT_VOID, CUtlBinaryBlock );
		SERIALIZE_TYPE( buf, AT_OBJECTID, DmObjectId_t );
		SERIALIZE_TYPE( buf, AT_COLOR, Color );
		SERIALIZE_TYPE( buf, AT_VECTOR2, Vector2D );
		SERIALIZE_TYPE( buf, AT_VECTOR3, Vector );
		SERIALIZE_TYPE( buf, AT_VECTOR4, Vector4D );
		SERIALIZE_TYPE( buf, AT_QANGLE, QAngle );
		SERIALIZE_TYPE( buf, AT_QUATERNION, Quaternion );
		SERIALIZE_TYPE( buf, AT_VMATRIX, VMatrix );
		SERIALIZE_ARRAY_TYPE( buf, AT_INT_ARRAY, int );
		SERIALIZE_ARRAY_TYPE( buf, AT_FLOAT_ARRAY, float );
		SERIALIZE_ARRAY_TYPE( buf, AT_BOOL_ARRAY, bool );
		SERIALIZE_ARRAY_TYPE( buf, AT_STRING_ARRAY, CUtlString );
		SERIALIZE_ARRAY_TYPE( buf, AT_VOID_ARRAY, CUtlBinaryBlock );
		SERIALIZE_ARRAY_TYPE( buf, AT_OBJECTID_ARRAY, DmObjectId_t );
		SERIALIZE_ARRAY_TYPE( buf, AT_COLOR_ARRAY, Color );
		SERIALIZE_ARRAY_TYPE( buf, AT_VECTOR2_ARRAY, Vector2D );
		SERIALIZE_ARRAY_TYPE( buf, AT_VECTOR3_ARRAY, Vector );
		SERIALIZE_ARRAY_TYPE( buf, AT_VECTOR4_ARRAY, Vector4D );
		SERIALIZE_ARRAY_TYPE( buf, AT_QANGLE_ARRAY, QAngle );
		SERIALIZE_ARRAY_TYPE( buf, AT_QUATERNION_ARRAY, Quaternion );
		SERIALIZE_ARRAY_TYPE( buf, AT_VMATRIX_ARRAY, VMatrix );
	default:
		AssertMsg( 0, "Cannot serialize elements or element arrays!\n" );
		return false;
	}

	return false;
}


//-----------------------------------------------------------------------------
// Serialize a single element in an array attribute
//-----------------------------------------------------------------------------
#define SERIALIZE_TYPED_ELEMENT( _index, _buf, _attributeType, _dataType )			\
	case _attributeType:															\
	{																				\
		if ( m_pData )																\
		{																			\
			const CUtlVector< _dataType > &array = *( CUtlVector< _dataType >* )m_pData;\
			return ::Serialize( buf, array[_index] );								\
		}																			\
		_dataType temp;																\
		CDmAttributeInfo< _dataType >::SetDefaultValue( temp );						\
		return ::Serialize( _buf, temp );											\
	}

bool CDmxAttribute::SerializeElement( int nIndex, CUtlBuffer &buf ) const
{
	if ( !IsArrayType( m_Type ) )
		return false;

	switch( m_Type )
	{
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_INT_ARRAY, int );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_FLOAT_ARRAY, float );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_BOOL_ARRAY, bool );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_STRING_ARRAY, CUtlString );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VOID_ARRAY, CUtlBinaryBlock );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_OBJECTID_ARRAY, DmObjectId_t );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_COLOR_ARRAY, Color );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VECTOR2_ARRAY, Vector2D );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VECTOR3_ARRAY, Vector );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VECTOR4_ARRAY, Vector4D );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_QANGLE_ARRAY, QAngle );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_QUATERNION_ARRAY, Quaternion );
		SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VMATRIX_ARRAY, VMatrix );

	default:
		AssertMsg( 0, "Cannot serialize elements!\n" );
		return false;
	}

	return false;
}


//-----------------------------------------------------------------------------
// Read from file
//-----------------------------------------------------------------------------
#define UNSERIALIZE_TYPE( _buf, _attributeType, _dataType )	\
	case _attributeType:									\
		Construct( (_dataType*)m_pData );					\
		return ::Unserialize( _buf, *(_dataType*)m_pData )

#define UNSERIALIZE_ARRAY_TYPE( _buf, _attributeType, _dataType )		\
	case _attributeType:												\
		Construct( (CUtlVector< _dataType > *)m_pData );				\
		return ::Unserialize( _buf, *(CUtlVector< _dataType >*)m_pData )

bool CDmxAttribute::Unserialize( DmAttributeType_t type, CUtlBuffer &buf )
{
	AllocateDataMemory( type );
	switch( type )
	{
	UNSERIALIZE_TYPE( buf, AT_INT, int );
	UNSERIALIZE_TYPE( buf, AT_FLOAT, float );
	UNSERIALIZE_TYPE( buf, AT_BOOL, bool );
	UNSERIALIZE_TYPE( buf, AT_STRING, CUtlString );
	UNSERIALIZE_TYPE( buf, AT_VOID, CUtlBinaryBlock );
	UNSERIALIZE_TYPE( buf, AT_OBJECTID, DmObjectId_t );
	UNSERIALIZE_TYPE( buf, AT_COLOR, Color );
	UNSERIALIZE_TYPE( buf, AT_VECTOR2, Vector2D );
	UNSERIALIZE_TYPE( buf, AT_VECTOR3, Vector );
	UNSERIALIZE_TYPE( buf, AT_VECTOR4, Vector4D );
	UNSERIALIZE_TYPE( buf, AT_QANGLE, QAngle );
	UNSERIALIZE_TYPE( buf, AT_QUATERNION, Quaternion );
	UNSERIALIZE_TYPE( buf, AT_VMATRIX, VMatrix );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_INT_ARRAY, int );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_FLOAT_ARRAY, float );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_BOOL_ARRAY, bool );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_STRING_ARRAY, CUtlString );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_VOID_ARRAY, CUtlBinaryBlock );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_OBJECTID_ARRAY, DmObjectId_t );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_COLOR_ARRAY, Color );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_VECTOR2_ARRAY, Vector2D );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_VECTOR3_ARRAY, Vector );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_VECTOR4_ARRAY, Vector4D );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_QANGLE_ARRAY, QAngle );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_QUATERNION_ARRAY, Quaternion );
	UNSERIALIZE_ARRAY_TYPE( buf, AT_VMATRIX_ARRAY, VMatrix );
	default:
		AssertMsg( 0, "Cannot unserialize elements or element arrays!\n" );
		return false;
	}

	return false;
}


//-----------------------------------------------------------------------------
// Read element from file
//-----------------------------------------------------------------------------
#define UNSERIALIZE_TYPED_ELEMENT( _buf, _attributeType, _dataType )	\
	case _attributeType:										\
	{															\
		if ( !bIsDataMemoryAllocated )							\
		{														\
			Construct( (CUtlVector< _dataType > *)m_pData );	\
		}														\
		_dataType temp;											\
		bool bReadElement = ::Unserialize( _buf, temp );		\
		if ( bReadElement )										\
		{														\
			GetArrayForEdit< _dataType >().AddToTail( temp );	\
		}														\
		return bReadElement;									\
	}															

bool CDmxAttribute::UnserializeElement( DmAttributeType_t type, CUtlBuffer &buf )
{
	if ( !IsArrayType( type ) )
		return false;

	bool bIsDataMemoryAllocated = ( m_Type == type );
	if ( !bIsDataMemoryAllocated )
	{
		AllocateDataMemory( type );
	}
	switch( type )
	{
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_INT_ARRAY, int );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_FLOAT_ARRAY, float );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_BOOL_ARRAY, bool );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_STRING_ARRAY, CUtlString );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_VOID_ARRAY, CUtlBinaryBlock );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_OBJECTID_ARRAY, DmObjectId_t );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_COLOR_ARRAY, Color );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_VECTOR2_ARRAY, Vector2D );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_VECTOR3_ARRAY, Vector );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_VECTOR4_ARRAY, Vector4D );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_QANGLE_ARRAY, QAngle );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_QUATERNION_ARRAY, Quaternion );
	UNSERIALIZE_TYPED_ELEMENT( buf, AT_VMATRIX_ARRAY, VMatrix );
	default:
		AssertMsg( 0, "Cannot unserialize elements!\n" );
		return false;
	}

	return false;
}


//-----------------------------------------------------------------------------
// Sets name
//-----------------------------------------------------------------------------
void CDmxAttribute::SetName( const char *pAttributeName )
{
	m_Name = s_AttributeNameSymbols.Find( pAttributeName );
}


//-----------------------------------------------------------------------------
// Sets values
//-----------------------------------------------------------------------------
void CDmxAttribute::SetValue( const char *pString )
{
	AllocateDataMemory( AT_STRING );
	CUtlString* pUtlString = (CUtlString*)m_pData;
	Construct( pUtlString );
	pUtlString->Set( pString );
}

void CDmxAttribute::SetValue( const void *pBuffer, size_t nLen )
{
	AllocateDataMemory( AT_VOID );
	CUtlBinaryBlock* pBlob = (CUtlBinaryBlock*)m_pData;
	Construct( pBlob );
	pBlob->Set( pBuffer, nLen );
}

// Untyped method for setting used by unpack
void CDmxAttribute::SetValue( DmAttributeType_t type, const void *pSrc, int nLen )
{
	if ( m_Type != type )
	{
		AllocateDataMemory( type );
	}
	Assert( nLen == CDmxAttribute::AttributeDataSize( type ) ); 
	if ( nLen > CDmxAttribute::AttributeDataSize( type ) )
	{
		nLen = CDmxAttribute::AttributeDataSize( type );
	}
	memcpy( m_pData, pSrc, nLen );
}


void CDmxAttribute::SetValue( const CDmxAttribute *pAttribute )
{
	DmAttributeType_t type = pAttribute->GetType();
	if ( !IsArrayType( type ) )
	{
		SetValue( type, pAttribute->m_pData, CDmxAttribute::AttributeDataSize( type ) );
	}
	else
	{
		// Copying array attributes not done yet..
		Assert( 0 );
	}
}

// Sets the attribute to its default value based on its type
#define SET_DEFAULT_VALUE( _dataType )	\
	case CDmAttributeInfo< _dataType >::ATTRIBUTE_TYPE:			\
		CDmAttributeInfo< _dataType >::SetDefaultValue( *reinterpret_cast< _dataType* >( m_pData ) );	\
		break;																	\
	case CDmAttributeInfo< CUtlVector< _dataType > >::ATTRIBUTE_TYPE:			\
		CDmAttributeInfo< CUtlVector< _dataType > >::SetDefaultValue( *reinterpret_cast< CUtlVector< _dataType > * >( m_pData ) );	\
		break

void CDmxAttribute::SetToDefaultValue()
{
	switch( GetType() )
	{
	SET_DEFAULT_VALUE( int );
	SET_DEFAULT_VALUE( float );
	SET_DEFAULT_VALUE( bool );
	SET_DEFAULT_VALUE( CUtlString );
	SET_DEFAULT_VALUE( CUtlBinaryBlock );
	SET_DEFAULT_VALUE( DmObjectId_t );
	SET_DEFAULT_VALUE( Color );
	SET_DEFAULT_VALUE( Vector2D );
	SET_DEFAULT_VALUE( Vector );
	SET_DEFAULT_VALUE( Vector4D );
	SET_DEFAULT_VALUE( QAngle );
	SET_DEFAULT_VALUE( Quaternion );
	SET_DEFAULT_VALUE( VMatrix );
	SET_DEFAULT_VALUE( CDmxElement* );

	default:
		break;
	}
}


//-----------------------------------------------------------------------------
// Convert to and from string
//-----------------------------------------------------------------------------
void CDmxAttribute::SetValueFromString( const char *pValue )
{
	switch ( GetType() )
	{
	case AT_UNKNOWN:
		break;

	case AT_STRING:
		SetValue( pValue );
		break;

	default:
		{
			int nLen = pValue ? Q_strlen( pValue ) : 0;
			if ( nLen == 0 )
			{
				SetToDefaultValue();
				break;
			}

			CUtlBuffer buf( pValue, nLen, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY );
			if ( !Unserialize( GetType(), buf ) )
			{
				SetToDefaultValue();
			}
		}
		break;
	}
}

const char *CDmxAttribute::GetValueAsString( char *pBuffer, size_t nBufLen ) const
{
	Assert( pBuffer );
	CUtlBuffer buf( pBuffer, nBufLen, CUtlBuffer::TEXT_BUFFER );
	Serialize( buf );
	return pBuffer;
}