1

public/isaverestore.h

@@ -0,0 +1,387 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef ISAVERESTORE_H
+#define ISAVERESTORE_H
+
+#include "string_t.h"
+#include "datamap.h"
+#include "mathlib/vmatrix.h"
+
+#if defined( _WIN32 )
+#pragma once
+#endif
+
+#ifndef CLIENT_DLL
+class SINGLE_INHERITANCE CBaseEntity;
+#endif
+
+class Vector;
+class VMatrix;
+struct edict_t;
+template< class T > class CHandle;
+typedef CHandle<CBaseEntity> EHANDLE;
+struct matrix3x4_t;
+
+class CSaveRestoreData;
+class CGameSaveRestoreInfo;
+
+class ISave;
+class IRestore;
+
+//-----------------------------------------------------------------------------
+
+#pragma pack(push,1)
+
+struct SaveRestoreRecordHeader_t
+{
+	unsigned short		size;
+	unsigned short		symbol;
+};
+
+
+#pragma pack(pop)
+
+//-----------------------------------------------------------------------------
+//
+// ISaveRestoreBlockHandler
+//
+//-----------------------------------------------------------------------------
+
+const int MAX_BLOCK_NAME_LEN = 31;
+const int SIZE_BLOCK_NAME_BUF = 31 + 1;
+
+//-------------------------------------
+
+abstract_class ISaveRestoreBlockHandler
+{
+public:
+	virtual const char *GetBlockName() = 0;
+
+	virtual void PreSave( CSaveRestoreData * ) = 0;					// Called immediately prior to save, generally used to set up any necessary tables
+	virtual void Save( ISave * ) = 0;
+	virtual void WriteSaveHeaders( ISave * ) = 0;					// Called after save to allow the writing out of any dictionaries/tables/indexes generated during save
+	virtual void PostSave() = 0;
+	
+	virtual void PreRestore() = 0;
+	virtual void ReadRestoreHeaders( IRestore * ) = 0;				// Called prior to Restore()
+	virtual void Restore( IRestore *, bool fCreatePlayers ) = 0;
+	virtual void PostRestore() = 0;
+};
+
+//-------------------------------------
+
+abstract_class ISaveRestoreBlockSet : public ISaveRestoreBlockHandler
+{
+public:
+	virtual void AddBlockHandler( ISaveRestoreBlockHandler *pHandler ) = 0;
+	virtual void RemoveBlockHandler( ISaveRestoreBlockHandler *pHandler ) = 0;
+	virtual void CallBlockHandlerRestore( ISaveRestoreBlockHandler *pHandler, int baseFilePos, IRestore *pRestore, bool fCreatePlayers ) = 0;
+};
+
+extern ISaveRestoreBlockSet *g_pGameSaveRestoreBlockSet;
+
+//-------------------------------------
+
+abstract_class CDefSaveRestoreBlockHandler : public ISaveRestoreBlockHandler
+{
+	virtual const char *GetBlockName() = 0;
+
+	virtual void PreSave( CSaveRestoreData * ) {}
+	virtual void Save( ISave * ) {}
+	virtual void WriteSaveHeaders( ISave * ) {}
+	virtual void PostSave() {}
+	
+	virtual void PreRestore() {}
+	virtual void ReadRestoreHeaders( IRestore * ) {}
+	virtual void Restore( IRestore *, bool fCreatePlayers ) {}
+	virtual void PostRestore() {}
+};
+
+//-----------------------------------------------------------------------------
+//
+// ISave
+//
+//-----------------------------------------------------------------------------
+
+abstract_class ISave
+{
+public:
+
+	//---------------------------------
+	// Logging
+	virtual void	StartLogging( const char *pszLogName ) = 0;
+	virtual void	EndLogging( void ) = 0;
+
+	//---------------------------------
+	virtual bool	IsAsync() = 0;
+
+	//---------------------------------
+
+	virtual int		GetWritePos() const = 0;
+	virtual void	SetWritePos(int pos) = 0;
+	
+	//---------------------------------
+	// Datamap based writing
+	//
+	
+	virtual int		WriteAll( const void *pLeafObject, datamap_t *pLeafMap ) = 0;
+	virtual int		WriteFields( const char *pname, const void *pBaseData, datamap_t *pMap, typedescription_t *pFields, int fieldCount ) = 0;
+
+	template <typename T>
+	int WriteAll( const T *pLeafObject )
+	{
+		return WriteAll( pLeafObject, &pLeafObject->m_DataMap );
+	}
+
+	//---------------------------------
+	// Block support
+	//
+	// Using these, one doesn't have to worry about queuing up the read pointer on restore if only
+	// a subset of the data is read
+	//
+	
+	virtual void	StartBlock( const char *pszBlockName ) = 0;
+	virtual void	StartBlock() = 0;
+	virtual void	EndBlock() = 0;
+	
+	//---------------------------------
+	// Primitive types
+	//
+	
+	virtual void	WriteShort( const short *value, int count = 1 ) = 0;
+	virtual void	WriteInt( const int *value, int count = 1 ) = 0;		// Save an int
+	inline void		WriteInt( const unsigned *value, int count = 1 ) { WriteInt( (int *)value, count );	}
+	virtual void	WriteBool( const bool *value, int count = 1 ) = 0;		// Save a bool
+	virtual void	WriteFloat( const float *value, int count = 1 ) = 0;	// Save a float
+	virtual void	WriteData( const char *pdata, int size ) = 0;		// Save a binary data block
+	virtual void	WriteString( const char *pstring ) = 0;			// Save a null-terminated string
+	virtual void	WriteString( const string_t *stringId, int count = 1 ) = 0;	// Save a null-terminated string (engine string)
+	virtual void	WriteVector( const Vector &value ) = 0;				// Save a vector
+	virtual void	WriteVector( const Vector *value, int count = 1 ) = 0;	// Save a vector array
+	virtual void	WriteQuaternion( const Quaternion &value ) = 0;				// Save a Quaternion
+	virtual void	WriteQuaternion( const Quaternion *value, int count = 1 ) = 0;	// Save a Quaternion array
+
+	// Note: All of the following will write out both a header and the data. On restore,
+	// this needs to be cracked
+	virtual void	WriteShort( const char *pname, const short *value, int count = 1 ) = 0;
+	virtual void	WriteInt( const char *pname, const int *value, int count = 1 ) = 0;		// Save an int
+	virtual void	WriteBool( const char *pname, const bool *value, int count = 1 ) = 0;		// Save a bool
+	virtual void	WriteFloat( const char *pname, const float *value, int count = 1 ) = 0;	// Save a float
+	virtual void	WriteData( const char *pname, int size, const char *pdata ) = 0;		// Save a binary data block
+	virtual void	WriteString( const char *pname, const char *pstring ) = 0;			// Save a null-terminated string
+	virtual void	WriteString( const char *pname, const string_t *stringId, int count = 1 ) = 0;	// Save a null-terminated string (engine string)
+	virtual void	WriteVector( const char *pname, const Vector &value ) = 0;				// Save a vector
+	virtual void	WriteVector( const char *pname, const Vector *value, int count = 1 ) = 0;	// Save a vector array
+	virtual void	WriteQuaternion( const char *pname, const Quaternion &value ) = 0;				// Save a Quaternion
+	virtual void	WriteQuaternion( const char *pname, const Quaternion *value, int count = 1 ) = 0;	// Save a Quaternion array
+	
+	//---------------------------------
+	// Game types
+	//
+	
+	virtual void	WriteTime( const char *pname, const float *value, int count = 1 ) = 0;	// Save a float (timevalue)
+	virtual void	WriteTick( const char *pname, const int *value, int count = 1 ) = 0;	// Save a tick (timevalue)
+	virtual void	WritePositionVector( const char *pname, const Vector &value ) = 0;		// Offset for landmark if necessary
+	virtual void	WritePositionVector( const char *pname, const Vector *value, int count = 1 ) = 0;	// array of pos vectors
+	virtual void	WriteFunction( datamap_t *pMap, const char *pname, inputfunc_t **value, int count = 1 ) = 0; // Save a function pointer
+
+	virtual void	WriteTime( const float *value, int count = 1 ) = 0;	// Save a float (timevalue)
+	virtual void	WriteTick( const int *value, int count = 1 ) = 0;	// Save a tick (timevalue)
+	virtual void	WritePositionVector( const Vector &value ) = 0;		// Offset for landmark if necessary
+	virtual void	WritePositionVector( const Vector *value, int count = 1 ) = 0;	// array of pos vectors
+
+	virtual void	WriteEntityPtr( const char *pname, CBaseEntity **ppEntity, int count = 1 ) = 0;
+	virtual void	WriteEdictPtr( const char *pname, edict_t **ppEdict, int count = 1 ) = 0;
+	virtual void	WriteEHandle( const char *pname, const EHANDLE *pEHandle, int count = 1 ) = 0;
+
+	virtual void	WriteEntityPtr( CBaseEntity **ppEntity, int count = 1 ) = 0;
+	virtual void	WriteEdictPtr( edict_t **ppEdict, int count = 1 ) = 0;
+	virtual void	WriteEHandle( const EHANDLE *pEHandle, int count = 1 ) = 0;
+
+	//---------------------------------
+	// Back door to support somewhat awkward ownership of game save/restore data
+	virtual CGameSaveRestoreInfo *GetGameSaveRestoreInfo() = 0;
+
+protected:
+	virtual ~ISave() {};
+};
+
+//-----------------------------------------------------------------------------
+//
+// IRestore
+//
+//-----------------------------------------------------------------------------
+
+abstract_class IRestore
+{
+public:
+
+	//---------------------------------
+
+	virtual int		GetReadPos() const = 0;
+	virtual void	SetReadPos( int pos ) = 0;
+
+	//---------------------------------
+	// Datamap based reading
+	//
+	
+	virtual int		ReadAll( void *pLeafObject, datamap_t *pLeafMap ) = 0;
+	
+	virtual int		ReadFields( const char *pname, void *pBaseData, datamap_t *pMap, typedescription_t *pFields, int fieldcount = 1 ) = 0;
+	virtual void	EmptyFields( void *pBaseData, typedescription_t *pFields, int fieldcount = 1 ) = 0;
+
+	template <typename T>
+	int ReadAll( T *pLeafObject )
+	{
+		return ReadAll( pLeafObject, &pLeafObject->m_DataMap );
+	}
+	
+	//---------------------------------
+	// Block support
+	//
+	
+	virtual void	StartBlock( SaveRestoreRecordHeader_t *pHeader ) = 0;
+	virtual void	StartBlock( char szBlockName[SIZE_BLOCK_NAME_BUF] ) = 0;
+	virtual void	StartBlock() = 0;
+	virtual void	EndBlock() = 0;
+	
+	//---------------------------------
+	// Field header cracking
+	//
+	
+	virtual void	ReadHeader( SaveRestoreRecordHeader_t *pheader ) = 0;
+	virtual int		SkipHeader() = 0; // skips the header, but returns the size of the field
+	virtual const char *StringFromHeaderSymbol( int symbol ) = 0;
+
+	//---------------------------------
+	// Primitive types
+	//
+	
+	virtual short	ReadShort( void ) = 0;
+	virtual int		ReadShort( short *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadInt( int *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
+	inline  int		ReadInt( unsigned *pValue, int count = 1, int nBytesAvailable = 0 ) { return ReadInt( (int *)pValue, count, nBytesAvailable ); }
+	virtual int		ReadInt( void ) = 0;
+	virtual int		ReadBool( bool *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadFloat( float *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadData( char *pData, int size, int nBytesAvailable ) = 0;
+	virtual void	ReadString( char *pDest, int nSizeDest, int nBytesAvailable ) = 0;			// A null-terminated string
+	virtual int		ReadString( string_t *pString, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadVector( Vector *pValue ) = 0;
+	virtual int		ReadVector( Vector *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadQuaternion( Quaternion *pValue ) = 0;
+	virtual int		ReadQuaternion( Quaternion *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
+	
+	//---------------------------------
+	// Game types
+	//
+	
+	virtual int		ReadTime( float *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadTick( int *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadPositionVector( Vector *pValue ) = 0;
+	virtual int		ReadPositionVector( Vector *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadFunction( datamap_t *pMap, inputfunc_t **pValue, int count = 1, int nBytesAvailable = 0) = 0;
+	
+	virtual int		ReadEntityPtr( CBaseEntity **ppEntity, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadEdictPtr( edict_t **ppEdict, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadEHandle( EHANDLE *pEHandle, int count = 1, int nBytesAvailable = 0 ) = 0;
+	virtual int		ReadVMatrix( VMatrix *pValue, int count = 1, int nBytesAvailable = 0) = 0;
+	virtual int		ReadVMatrixWorldspace( VMatrix *pValue, int count = 1, int nBytesAvailable = 0) = 0;
+	virtual int		ReadMatrix3x4Worldspace( matrix3x4_t *pValue, int nElems = 1, int nBytesAvailable = 0 ) = 0;
+
+	//---------------------------------
+
+	virtual bool	GetPrecacheMode( void ) = 0;
+
+	//---------------------------------
+	// Back door to support somewhat awkward ownership of game save/restore data
+	virtual CGameSaveRestoreInfo *GetGameSaveRestoreInfo() = 0;
+
+protected:
+	virtual ~IRestore() {};
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: The operations necessary to save and restore custom types (FIELD_CUSTOM)
+//
+//
+
+struct SaveRestoreFieldInfo_t
+{
+	void *			   pField;
+
+	// Note that it is legal for the following two fields to be NULL,
+	// though it may be disallowed by implementors of ISaveRestoreOps
+	void *			   pOwner;
+	typedescription_t *pTypeDesc;
+};
+
+abstract_class ISaveRestoreOps
+{
+public:
+	// save data type interface
+	virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave ) = 0;
+	virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore ) = 0;
+
+	virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) = 0;
+	virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) = 0;
+	virtual bool Parse( const SaveRestoreFieldInfo_t &fieldInfo, char const* szValue ) = 0;
+
+	//---------------------------------
+
+	void Save( void *pField, ISave *pSave )				{ SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; Save( fieldInfo, pSave ); }
+	void Restore( void *pField, IRestore *pRestore )	{ SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; Restore( fieldInfo, pRestore ); }
+
+	bool IsEmpty( void *pField)							{ SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; return IsEmpty( fieldInfo ); }
+	void MakeEmpty( void *pField)						{ SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; MakeEmpty( fieldInfo ); }
+	bool Parse( void *pField, char const *pszValue )	{ SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; return Parse( fieldInfo, pszValue ); }
+};
+
+//-------------------------------------
+
+class CDefSaveRestoreOps : public ISaveRestoreOps
+{
+public:
+	// save data type interface
+	virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave ) {}
+	virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore ) {}
+
+	virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) { return false; }
+	virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) {}
+	virtual bool Parse( const SaveRestoreFieldInfo_t &fieldInfo, char const* szValue ) { return false; }
+};
+
+
+//-----------------------------------------------------------------------------
+// Used by ops that deal with pointers
+//-----------------------------------------------------------------------------
+class CClassPtrSaveRestoreOps : public CDefSaveRestoreOps
+{
+public:
+	virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo )
+	{
+		void **ppClassPtr = (void **)fieldInfo.pField;
+		int nObjects = fieldInfo.pTypeDesc->fieldSize;
+		for ( int i = 0; i < nObjects; i++ )
+		{
+			if ( ppClassPtr[i] != NULL )
+				return false;
+		}
+		return true;
+	}
+
+	virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo )
+	{
+		memset( fieldInfo.pField, 0, fieldInfo.pTypeDesc->fieldSize * sizeof( void * ) );
+	}
+};
+
+
+//=============================================================================
+
+#endif // ISAVERESTORE_H