path: root/sp/src/public/isaverestore.h

//========= 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