Update CTSListBase & various schema system naming changes (#253)

public/schemasystem/schemasystem.h

@@ -20,9 +20,9 @@ struct ResourceManifestDesc_t;
 
 enum SchemaTypeScope_t : uint8
 {
-	SCHEMA_TYPESCOPE_GLOBAL = 0,
+	SCHEMA_GLOBAL_TYPE_SCOPE = 0,
-	SCHEMA_TYPESCOPE_LOCAL,
+	SCHEMA_MODULE_LOCAL_TYPE_SCOPE,
-	SCHEMA_TYPESCOPE_DEFAULT,
+	SCHEMA_DEFAULT_TYPE_SCOPE,
 };
 
 typedef void (*CompleteModuleRegistrationCallbackFn_t)(void*);
@@ -42,7 +42,7 @@ public:
 	virtual SchemaMetaInfoHandle_t<CSchemaType_Ptr>				Type_Ptr( CSchemaType* pObjectType ) = 0;
 	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic>			Type_Atomic( const char* pszAtomicName, uint16 nSize, uint8 nAlignment ) = 0;
 	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_T>		Type_Atomic_T( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, CSchemaType* pTemplateType ) = 0;
-	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_CollectionOfT> Type_Atomic_CollectionOfT( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, uint16 nElementSize, CSchemaType* pTemplateType, SchemaAtomicManipulatorFn_t manipulator ) = 0;
+	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_CollectionOfT> Type_Atomic_CollectionOfT( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, uint16 nElementSize, CSchemaType* pTemplateType, SchemaCollectionManipulatorFn_t manipulator ) = 0;
 	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_TT>		Type_Atomic_TT( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, CSchemaType* pTemplateType, CSchemaType* pTemplateType2 ) = 0;
 	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_I>		Type_Atomic_I( const char* pszAtomicName, uint16 nSize, uint8 nAlignment, int nInterger ) = 0;
 	virtual SchemaMetaInfoHandle_t<CSchemaType_DeclaredClass>	Type_DeclaredClass( const char* pszClassName ) = 0;
@@ -53,7 +53,7 @@ public:
 
 	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic>			FindType_Atomic( int nAtomicID ) = 0;
 	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_T>		FindType_Atomic_T( int nAtomicID, CSchemaType* pTemplateType ) = 0;
-	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_CollectionOfT> FindType_Atomic_CollectionOfT( int nAtomicID, CSchemaType* pTemplateType, SchemaAtomicManipulatorFn_t manipulator ) = 0;
+	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_CollectionOfT> FindType_Atomic_CollectionOfT( int nAtomicID, CSchemaType* pTemplateType, SchemaCollectionManipulatorFn_t manipulator ) = 0;
 	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_TT> 		FindType_Atomic_TT( int nAtomicID, CSchemaType* pTemplateType, CSchemaType* pTemplateType2 ) = 0;
 	virtual SchemaMetaInfoHandle_t<CSchemaType_Atomic_I> 		FindType_Atomic_I( int nAtomicID, int nInteger ) = 0;
 	
@@ -84,9 +84,9 @@ public:
 	CSchemaSystemTypeScope* m_pGlobalTypeScope;
 	
 	bool m_bBuiltinTypesInitialized;
-	CSchemaType_Builtin m_BuiltinTypes[SCHEMA_BUILTIN_COUNT];
+	CSchemaType_Builtin m_BuiltinTypes[SCHEMA_BUILTIN_TYPE_COUNT];
 	
-	CSchemaPtrMap<SchemaMetaInfoHandle_t<CSchemaType>, CSchemaType_Ptr*> m_Ptrs;
+	CSchemaPtrMap<SchemaMetaInfoHandle_t<CSchemaType>, CSchemaType_Ptr*> m_Pointers;
 	CSchemaPtrMap<int, CSchemaType_Atomic*>							m_Atomics;
 	CSchemaPtrMap<AtomicTypeInfo_T_t, CSchemaType_Atomic_T*>		m_AtomicsT;
 	CSchemaPtrMap<AtomicTypeInfo_T_t, CSchemaType_Atomic_CollectionOfT*> m_AtomicsCollectionOfT;

public/schemasystem/schematypes.h

@@ -54,44 +54,42 @@ enum SchemaEnumFlags_t
 enum SchemaTypeCategory_t : uint8
 {
 	SCHEMA_TYPE_BUILTIN = 0,
-	SCHEMA_TYPE_PTR,
+	SCHEMA_TYPE_POINTER,
 	SCHEMA_TYPE_BITFIELD,
 	SCHEMA_TYPE_FIXED_ARRAY,
 	SCHEMA_TYPE_ATOMIC,
 	SCHEMA_TYPE_DECLARED_CLASS,
 	SCHEMA_TYPE_DECLARED_ENUM,
-	SCHEMA_TYPE_NONE,
+	SCHEMA_TYPE_INVALID,
 };
 
 enum SchemaAtomicCategory_t : uint8
 {
-	SCHEMA_ATOMIC_BASIC = 0,
+	SCHEMA_ATOMIC_PLAIN = 0,
 	SCHEMA_ATOMIC_T,
 	SCHEMA_ATOMIC_COLLECTION_OF_T,
-	SCHEMA_ATOMIC_TF,
 	SCHEMA_ATOMIC_TT,
-	SCHEMA_ATOMIC_TTF,
 	SCHEMA_ATOMIC_I,
-	SCHEMA_ATOMIC_NONE,
+	SCHEMA_ATOMIC_INVALID,
 };
 
 enum SchemaBuiltinType_t
 {
-	SCHEMA_BUILTIN_INVALID = 0,
+	SCHEMA_BUILTIN_TYPE_INVALID = 0,
-	SCHEMA_BUILTIN_VOID,
+	SCHEMA_BUILTIN_TYPE_VOID,
-	SCHEMA_BUILTIN_CHAR,
+	SCHEMA_BUILTIN_TYPE_CHAR,
-	SCHEMA_BUILTIN_INT8,
+	SCHEMA_BUILTIN_TYPE_INT8,
-	SCHEMA_BUILTIN_UINT8,
+	SCHEMA_BUILTIN_TYPE_UINT8,
-	SCHEMA_BUILTIN_INT16,
+	SCHEMA_BUILTIN_TYPE_INT16,
-	SCHEMA_BUILTIN_UINT16,
+	SCHEMA_BUILTIN_TYPE_UINT16,
-	SCHEMA_BUILTIN_INT32,
+	SCHEMA_BUILTIN_TYPE_INT32,
-	SCHEMA_BUILTIN_UINT32,
+	SCHEMA_BUILTIN_TYPE_UINT32,
-	SCHEMA_BUILTIN_INT64,
+	SCHEMA_BUILTIN_TYPE_INT64,
-	SCHEMA_BUILTIN_UINT64,
+	SCHEMA_BUILTIN_TYPE_UINT64,
-	SCHEMA_BUILTIN_FLOAT32,
+	SCHEMA_BUILTIN_TYPE_FLOAT32,
-	SCHEMA_BUILTIN_FLOAT64,
+	SCHEMA_BUILTIN_TYPE_FLOAT64,
-	SCHEMA_BUILTIN_BOOL,
+	SCHEMA_BUILTIN_TYPE_BOOL,
-	SCHEMA_BUILTIN_COUNT,
+	SCHEMA_BUILTIN_TYPE_COUNT,
 };
 
 enum SchemaClassManipulatorAction_t
@@ -105,19 +103,19 @@ enum SchemaClassManipulatorAction_t
 	SCHEMA_CLASS_MANIPULATOR_ACTION_GET_SCHEMA_BINDING,
 };
 
-enum SchemaAtomicManipulatorAction_t
+enum SchemaCollectionManipulatorAction_t
 {
-	SCHEMA_ATOMIC_MANIPULATOR_ACTION_GET_COUNT = 0,
+	SCHEMA_COLLECTION_MANIPULATOR_ACTION_GET_COUNT = 0,
-	SCHEMA_ATOMIC_MANIPULATOR_ACTION_GET_ELEMENT_CONST,
+	SCHEMA_COLLECTION_MANIPULATOR_ACTION_GET_ELEMENT_CONST,
-	SCHEMA_ATOMIC_MANIPULATOR_ACTION_GET_ELEMENT,
+	SCHEMA_COLLECTION_MANIPULATOR_ACTION_GET_ELEMENT,
-	SCHEMA_ATOMIC_MANIPULATOR_ACTION_SWAP_ELEMENTS,
+	SCHEMA_COLLECTION_MANIPULATOR_ACTION_SWAP_ELEMENTS,
-	SCHEMA_ATOMIC_MANIPULATOR_ACTION_INSERT_BEFORE,
+	SCHEMA_COLLECTION_MANIPULATOR_ACTION_INSERT_BEFORE,
-	SCHEMA_ATOMIC_MANIPULATOR_ACTION_REMOVE_MULTIPLE,
+	SCHEMA_COLLECTION_MANIPULATOR_ACTION_REMOVE_MULTIPLE,
-	SCHEMA_ATOMIC_MANIPULATOR_ACTION_SET_COUNT,
+	SCHEMA_COLLECTION_MANIPULATOR_ACTION_SET_COUNT,
 };
 
 typedef void* (*SchemaClassManipulatorFn_t)(SchemaClassManipulatorAction_t, void*, void*);
-typedef void* (*SchemaAtomicManipulatorFn_t)(SchemaAtomicManipulatorAction_t, void*, void*, void*);
+typedef void* (*SchemaCollectionManipulatorFn_t)(SchemaCollectionManipulatorAction_t, void*, void*, void*);
 
 inline uint32 CSchemaType_Hash( const char *pString, int len )
 {
@@ -129,7 +127,8 @@ struct SchemaMetaInfoHandle_t
 {
 	SchemaMetaInfoHandle_t() : m_pObj( NULL ) {}
 	SchemaMetaInfoHandle_t( T *obj ) : m_pObj( obj ) {}
-	T* Get() { return m_pObj; }
+	T* Get() const { return m_pObj; }
+	bool operator<( const SchemaMetaInfoHandle_t& rhs ) const { return m_pObj < rhs.m_pObj; }
 
 	T* m_pObj;
 };
@@ -204,7 +203,7 @@ public:
 class CSchemaType_Atomic_CollectionOfT : public CSchemaType_Atomic_T
 {
 public:
-	SchemaAtomicManipulatorFn_t m_pfnManipulator;
+	SchemaCollectionManipulatorFn_t m_pfnManipulator;
 	uint16 m_nElementSize;
 };
 
@@ -246,7 +245,7 @@ public:
 class CSchemaType_Bitfield : public CSchemaType
 {
 public:
-	int m_nSize;
+	int m_nBitfieldCount;
 };
 
 struct SchemaMetadataEntryData_t
@@ -362,8 +361,8 @@ class CSchemaEnumInfo : public SchemaEnumInfoData_t
 
 struct SchemaAtomicTypeInfo_t
 {
-	const char* m_pszName1;
+	const char* m_pszName;
-	const char* m_pszName2;
+	const char* m_pszTokenName;
 	
 	int m_nAtomicID;
 	
@@ -373,41 +372,64 @@ struct SchemaAtomicTypeInfo_t
 
 struct AtomicTypeInfo_T_t
 {
+	bool operator<( const AtomicTypeInfo_T_t& rhs ) const 
+	{ 
+		if ( m_nAtomicID != rhs.m_nAtomicID )
+			return m_nAtomicID < rhs.m_nAtomicID;
+		
+		if ( m_pTemplateType != rhs.m_pTemplateType )
+			return m_pTemplateType < rhs.m_pTemplateType;
+		
+		return m_pfnManipulator < rhs.m_pfnManipulator;
+	}
+	
 	int m_nAtomicID;
 	CSchemaType* m_pTemplateType;
-	SchemaAtomicManipulatorFn_t m_pfnManipulator;
+	SchemaCollectionManipulatorFn_t m_pfnManipulator;
-};
-
-struct AtomicTypeInfo_TF_t
-{
-	int m_nAtomicID;
-	CSchemaType* m_pTemplateType;
-	int m_nFuncPtrSize;
 };
 
 struct AtomicTypeInfo_TT_t
 {
+	bool operator<( const AtomicTypeInfo_TT_t& rhs ) const 
+	{ 
+		if ( m_nAtomicID != rhs.m_nAtomicID )
+			return m_nAtomicID < rhs.m_nAtomicID;
+		
+		if ( m_pTemplateType != rhs.m_pTemplateType )
+			return m_pTemplateType < rhs.m_pTemplateType;
+		
+		return m_pTemplateType2 < rhs.m_pTemplateType2;
+	}
+	
 	int m_nAtomicID;
 	CSchemaType* m_pTemplateType;
 	CSchemaType* m_pTemplateType2;
 };
 
-struct AtomicTypeInfo_TTF_t
-{
-	int m_nAtomicID;
-	CSchemaType* m_pTemplateType;
-	CSchemaType* m_pTemplateType2;
-	int m_nFuncPtrSize;
-};
-
 struct AtomicTypeInfo_I_t
 {
+	bool operator<( const AtomicTypeInfo_I_t& rhs ) const 
+	{ 
+		if ( m_nAtomicID != rhs.m_nAtomicID )
+			return m_nAtomicID < rhs.m_nAtomicID;
+
+		return m_nInteger < rhs.m_nInteger;
+	}
+	
 	int m_nAtomicID;
 	int m_nInteger;
 };
 
 struct TypeAndCountInfo_t
 {
+	bool operator<( const TypeAndCountInfo_t& rhs ) const 
+	{ 
+		if ( m_nElementCount != rhs.m_nElementCount )
+			return m_nElementCount < rhs.m_nElementCount;
+		
+		return m_pElementType < rhs.m_pElementType;
+	}
+	
 	int m_nElementCount;
 	CSchemaType* m_pElementType;
 };

public/tier0/tslist.h

@@ -127,7 +127,7 @@ union TSLIST_HEAD_ALIGN TSLHead_t
 #endif
 
 //-------------------------------------
-class TSLIST_HEAD_ALIGN CTSListBase
+class TSLIST_HEAD_ALIGN PLATFORM_CLASS CTSListBase
 {
 public:
 
@@ -159,153 +159,18 @@ private:
 	static void * operator new[] ( size_t size );
 	static void operator delete [] ( void *p);
 	
+	void InternalPush( TSLNodeBase_t *pNode );
+	TSLNodeBase_t *InternalPop();
+	
 public:
 
-	CTSListBase()
+	CTSListBase();
-	{
+	~CTSListBase();
-		if ( ((size_t)&m_Head) % TSLIST_HEAD_ALIGNMENT != 0 )
-		{
-			Plat_FatalErrorFunc( "CTSListBase: Misaligned list\n" );
-			DebuggerBreak();
-		}
 
-#ifdef USE_NATIVE_SLIST
+	void Push( TSLNodeBase_t *pNode ) { InternalPush( pNode ); }
-		InitializeSListHead( &m_Head );
+	TSLNodeBase_t *Pop() { return InternalPop(); }
-#elif defined(PLATFORM_64BITS)
-		m_Head.value64x128 = int128_zero();
-#else
-		m_Head.value64x128 = (int64)0;
-#endif
-	}
 
-	~CTSListBase()
+	TSLNodeBase_t *Detach();
-	{
-		Detach();
-	}
-
-	TSLNodeBase_t *Push( TSLNodeBase_t *pNode )
-	{
-#ifdef _DEBUG
-		if ( (size_t)pNode % TSLIST_NODE_ALIGNMENT != 0 )
-		{
-			Plat_FatalErrorFunc( "CTSListBase: Misaligned node\n" );
-			DebuggerBreak();
-		}
-#endif
-
-#ifdef USE_NATIVE_SLIST
-#ifdef _X360
-		// integrated write-release barrier
-		return (TSLNodeBase_t *)InterlockedPushEntrySListRelease( &m_Head, pNode );
-#else
-		return (TSLNodeBase_t *)InterlockedPushEntrySList( &m_Head, pNode );
-#endif
-#else
-		TSLHead_t oldHead;
-		TSLHead_t newHead;
-
-		#if defined( PLATFORM_PS3 ) || defined( PLATFORM_X360 )
-		__lwsync(); // write-release barrier
-		#endif
-
-#ifdef PLATFORM_64BITS
-		newHead.value.Padding = 0;
-#endif
-		for (;;)
-		{
-			oldHead.value64x128 = m_Head.value64x128;
-			pNode->Next = oldHead.value.Next;
-			newHead.value.Next = pNode;
-			
-			newHead.value32.DepthAndSequence = oldHead.value32.DepthAndSequence + 0x10001;
-			
-			
-			if ( ThreadInterlockedAssignIf64x128( &m_Head.value64x128, newHead.value64x128, oldHead.value64x128 ) )
-			{
-				break;
-			}
-			ThreadPause();
-		};
-
-		return (TSLNodeBase_t *)oldHead.value.Next;
-#endif
-	}
-
-	TSLNodeBase_t *Pop()
-	{
-#ifdef USE_NATIVE_SLIST
-#ifdef _X360
-		// integrated read-acquire barrier
-		TSLNodeBase_t *pNode = (TSLNodeBase_t *)InterlockedPopEntrySListAcquire( &m_Head );
-#else
-		TSLNodeBase_t *pNode = (TSLNodeBase_t *)InterlockedPopEntrySList( &m_Head );
-#endif
-		return pNode;
-#else
-		TSLHead_t oldHead;
-		TSLHead_t newHead;
-
-#ifdef PLATFORM_64BITS
-		newHead.value.Padding = 0;
-#endif
-		for (;;)
-		{
-			oldHead.value64x128 = m_Head.value64x128;
-			if ( !oldHead.value.Next )
-				return NULL;
-
-			newHead.value.Next = oldHead.value.Next->Next;
-			newHead.value32.DepthAndSequence = oldHead.value32.DepthAndSequence	- 1;
-
-
-			if ( ThreadInterlockedAssignIf64x128( &m_Head.value64x128, newHead.value64x128, oldHead.value64x128 ) )
-			{
-				#if defined( PLATFORM_PS3 ) || defined( PLATFORM_X360 )
-					__lwsync(); // read-acquire barrier
-				#endif
-				break;
-			}
-			ThreadPause();
-		};
-
-		return (TSLNodeBase_t *)oldHead.value.Next;
-#endif
-	}
-
-	TSLNodeBase_t *Detach()
-	{
-#ifdef USE_NATIVE_SLIST
-		TSLNodeBase_t *pBase = (TSLNodeBase_t *)InterlockedFlushSList( &m_Head );
-#if defined( _X360 ) || defined( _PS3 )
-		__lwsync(); // read-acquire barrier
-#endif
-		return pBase;
-#else
-		TSLHead_t oldHead;
-		TSLHead_t newHead;
-
-#ifdef PLATFORM_64BITS
-		newHead.value.Padding = 0;
-#endif
-		do
-		{
-			ThreadPause();
-
-			oldHead.value64x128 = m_Head.value64x128;
-			if ( !oldHead.value.Next )
-				return NULL;
-
-			newHead.value.Next = NULL;
-			// <sergiy> the reason for AND'ing it instead of poking a short into memory 
-			//          is probably to avoid store forward issues, but I'm not sure because
-			//          I didn't construct this code. In any case, leaving it as is on big-endian
-			newHead.value32.DepthAndSequence = oldHead.value32.DepthAndSequence & 0xffff0000;
-
-		} while( !ThreadInterlockedAssignIf64x128( &m_Head.value64x128, newHead.value64x128, oldHead.value64x128 ) );
-
-		return (TSLNodeBase_t *)oldHead.value.Next;
-#endif
-	}
 
 	TSLHead_t *AccessUnprotected()
 	{