source-engine/public/gcsdk/sharedobject.h

306 lines
10 KiB
C
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Base class for objects that are kept in synch between client and server
//
//=============================================================================
#ifndef SHAREDOBJECT_H
#define SHAREDOBJECT_H
#ifdef _WIN32
#pragma once
#endif
// ENABLE_SO_OVERWRITE_PARANOIA can be set to either 0 or 1. If enabled, it will add
// extra fields to every CSharedObject instance to try and detect overwrites at the
// cost of additional runtime memory.
#define ENABLE_SO_OVERWRITE_PARANOIA 0
// ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA can be set to either 0 or 1. If enabled, it
// will add extra fields to every CSharedObject instance to try and detect issues with
// constructions/destruction (ie., double-deletes, etc.), including reference counting.
#define ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA (defined( STAGING_ONLY ))
#include "tier0/memdbgon.h"
namespace GCSDK
{
class CSQLAccess;
class CSharedObject;
typedef CSharedObject *(*SOCreationFunc_t)( );
class CSharedObjectCache;
//----------------------------------------------------------------------------
// Purpose: Abstract base class for objects that are shared between the GC and
// a gameserver/client. These can also be stored in the database.
//----------------------------------------------------------------------------
class CSharedObject
{
friend class CGCSharedObjectCache;
friend class CSharedObjectCache;
public:
#ifdef GC
virtual ~CSharedObject()
{
#if ENABLE_SO_OVERWRITE_PARANOIA
m_pThis = NULL;
#endif // ENABLE_SO_OVERWRITE_PARANOIA
#if ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
AssertMsg2( m_nRefCount == 0, "Deleting shared object type %d with refcount %d", m_nSOTypeID, m_nRefCount );
m_nSOTypeID = -1;
m_nRefCount = -1;
#endif // ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
}
#if ENABLE_SO_OVERWRITE_PARANOIA
CSharedObject *m_pThis;
#endif // ENABLE_SO_OVERWRITE_PARANOIA
#if ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
int m_nRefCount;
mutable int m_nSOTypeID;
#endif // ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
void Check() const
{
#if ENABLE_SO_OVERWRITE_PARANOIA
Assert( m_pThis == this );
#endif // ENABLE_SO_OVERWRITE_PARANOIA
#if ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
Assert( m_nRefCount >= 0 );
if ( m_nSOTypeID == kSharedObject_UnassignedType )
{
m_nSOTypeID = GetTypeID();
}
Assert( m_nSOTypeID >= 0 );
#endif // ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
}
#else
virtual ~CSharedObject() {}
#endif
virtual int GetTypeID() const = 0;
virtual bool BParseFromMessage( const CUtlBuffer & buffer ) = 0;
virtual bool BParseFromMessage( const std::string &buffer ) = 0;
virtual bool BUpdateFromNetwork( const CSharedObject & objUpdate ) = 0;
virtual bool BIsKeyLess( const CSharedObject & soRHS ) const = 0;
virtual void Copy( const CSharedObject & soRHS ) = 0;
virtual void Dump() const = 0;
virtual bool BShouldDeleteByCache() const { return true; }
virtual CUtlString GetDebugString() const { return PchClassName( GetTypeID() ); };
bool BIsKeyEqual( const CSharedObject & soRHS ) const;
static void RegisterFactory( int nTypeID, SOCreationFunc_t fnFactory, uint32 unFlags, const char *pchClassName );
static CSharedObject *Create( int nTypeID );
static uint32 GetTypeFlags( int nTypeID );
static const char *PchClassName( int nTypeID );
static const char *PchClassBuildCacheNodeName( int nTypeID );
static const char *PchClassCreateNodeName( int nTypeID );
static const char *PchClassUpdateNodeName( int nTypeID );
#ifdef GC
virtual bool BIsNetworked() const { return true; }
virtual bool BIsDatabaseBacked() const { return true; }
virtual bool BYieldingAddToDatabase();
virtual bool BYieldingWriteToDatabase( const CUtlVector< int > &fields );
virtual bool BYieldingRemoveFromDatabase();
virtual bool BYieldingAddInsertToTransaction( CSQLAccess & sqlAccess ) { return false; }
virtual bool BYieldingAddWriteToTransaction( CSQLAccess & sqlAccess, const CUtlVector< int > &fields ) { return false; }
virtual bool BYieldingAddRemoveToTransaction( CSQLAccess & sqlAccess ) { return false; }
virtual bool BAddToMessage( CUtlBuffer & bufOutput ) const = 0;
virtual bool BAddToMessage( std::string *pBuffer ) const = 0;
virtual bool BAddDestroyToMessage( CUtlBuffer & bufDestroy ) const = 0;
virtual bool BAddDestroyToMessage( std::string *pBuffer ) const = 0;
virtual bool BParseFromMemcached( CUtlBuffer & buffer ) { return false; }
virtual bool BAddToMemcached( CUtlBuffer & bufOutput ) const { return false; }
bool BSendCreateToSteamID( const CSteamID & steamID, const CSteamID & ownerID, uint64 ulVersion ) const;
bool BSendDestroyToSteamID( const CSteamID & steamID, const CSteamID & ownerID, uint64 ulVersion ) const;
#ifdef DBGFLAG_VALIDATE
virtual void Validate( CValidator &validator, const char *pchName );
static void ValidateStatics( CValidator & validator );
#endif
protected:
/*
// Dirty bit modification. Do not call these directly on SharedObjects. Call them
// on the cache that owns the object so they can be added/removed from the right lists.
virtual void DirtyField( int nField ) = 0;
virtual void MakeDatabaseClean() = 0;
virtual void MakeNetworkClean() = 0;
*/
#endif // GC
#ifdef GC
CSharedObject()
{
#if ENABLE_SO_OVERWRITE_PARANOIA
m_pThis = this;
#endif // ENABLE_SO_OVERWRITE_PARANOIA
#if ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
m_nRefCount = 0;
m_nSOTypeID = kSharedObject_UnassignedType;
#endif // ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
}
#endif
private:
#if ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
enum { kSharedObject_UnassignedType = -999 };
#endif // ENABLE_SO_CONSTRUCT_DESTRUCT_PARANOIA
struct SharedObjectInfo_t
{
SOCreationFunc_t m_pFactoryFunction;
uint32 m_unFlags;
const char *m_pchClassName;
CUtlString m_sBuildCacheSubNodeName;
CUtlString m_sUpdateNodeName;
CUtlString m_sCreateNodeName;
};
static CUtlMap<int, SharedObjectInfo_t> sm_mapFactories;
public:
static const CUtlMap<int, SharedObjectInfo_t> & GetFactories() { return sm_mapFactories; }
};
typedef CUtlVectorFixedGrowable<CSharedObject *, 1> CSharedObjectVec;
#ifdef GC
//this class manages the stats for the shared objects, such as how many exist, how many have been sent, how many have been created, how many destroyed
class CSharedObjectStats
{
public:
CSharedObjectStats();
//called to register a shared object class given a type ID and name. This will return false if
//a type of this ID is already registered
void RegisterSharedObjectType( int nTypeID, const char* pszTypeName );
//called to track when a shared object is created/destroyed to update the running total
void TrackSharedObjectLifetime( int nTypeID, int32 nCount );
//called when a shared object is created to track its creation
void TrackSharedObjectSendCreate( int nTypeID, uint32 nCount );
//called when a shared object is destroyed to track counts
void TrackSharedObjectSendDestroy( int nTypeID, uint32 nCount );
//tracks a new subscription
void TrackSubscription( int nTypeID, uint32 nFlags, uint32 nNumSubscriptions );
//called when a shared object is sent
void TrackSharedObjectSend( int nTypeID, uint32 nNumClients, uint32 nMsgSize );
//reset the stats for all the caches
void ResetStats();
//called to start/stop collecting stats
void StartCollectingStats();
void StopCollectingStats();
bool IsCollectingStats() const { return m_bCollectingStats; }
//called to report the currently collected stats
void ReportCollectedStats() const;
private:
struct SOStats_t
{
SOStats_t();
void ResetStats();
//the text name of this cache
CUtlString m_sName;
//the number of outstanding SO cache objects of this type. This is not cleared
uint32 m_nNumActive;
//the type ID of this stat
int m_nTypeID;
//the total number that have been created/destroyed. Active is difference between these
uint32 m_nNumCreated;
uint32 m_nNumDestroyed;
//how many bytes we have sent (raw, and multiplexed to multiple subscribers)
uint64 m_nRawBytesSent;
uint64 m_nMultiplexedBytesSent;
//the number of sends since our last clear
uint32 m_nNumSends;
//how many subscriptions we have gotten by various subscription types
uint32 m_nNumSubOwner;
uint32 m_nNumSubOtherUsers;
uint32 m_nNumSubGameServer;
};
//sort function that controls the order that the SO stats are presented in the report
static bool SortSOStatsSent( const SOStats_t* pLhs, const SOStats_t* pRhs );
static bool SortSOStatsSubscribe( const SOStats_t* pLhs, const SOStats_t* pRhs );
//to compact the memory space for wide ranging type IDs, the list of stats has two components, an array that can be looked up
//via the type ID which maps to a stat index (or invalid index if no mapping is registered)
static const uint16 knInvalidIndex = ( uint16 )-1;
CUtlVector< uint16 > m_vTypeToIndex;
CUtlVector< SOStats_t > m_Stats;
//are we currently collecting stats or not?
bool m_bCollectingStats;
//the time that we've been collecting
CJobTime m_CollectTime;
uint64 m_nMicroSElapsed;
};
//global stat tracker
extern CSharedObjectStats g_SharedObjectStats;
#endif
//----------------------------------------------------------------------------
// Purpose: Templatized function to use as a factory method for
// CSharedObject subclasses
//----------------------------------------------------------------------------
template<typename SharedObjectSubclass_t>
CSharedObject *CreateSharedObjectSubclass()
{
return new SharedObjectSubclass_t();
}
// Version that always asserts and returns NULL, for SOs that should not be auto-created this way
template<int nSharedObjectType>
CSharedObject *CreateSharedObjectSubclassProhibited()
{
AssertMsg( false, "Attempting to auto-create object of type %d which does not allow SO-based creation", nSharedObjectType );
return NULL;
}
#ifdef GC
#define REG_SHARED_OBJECT_SUBCLASS( derivedClass, flags ) GCSDK::CSharedObject::RegisterFactory( derivedClass::k_nTypeID, GCSDK::CreateSharedObjectSubclass<derivedClass>, (flags), #derivedClass )
// GC only -- sharedobjects that cannot be auto-created by the SO code, and might not have a specific derived class that
// publicly implements the interface
#define REG_SHARED_OBJECT_SUBCLASS_BY_ID_NOCREATE( strName, nTypeID, flags ) \
GCSDK::CSharedObject::RegisterFactory( nTypeID, CreateSharedObjectSubclassProhibited<nTypeID>, (flags), strName )
#else
#define REG_SHARED_OBJECT_SUBCLASS( derivedClass ) GCSDK::CSharedObject::RegisterFactory( derivedClass::k_nTypeID, GCSDK::CreateSharedObjectSubclass<derivedClass>, 0, #derivedClass )
#endif
} // namespace GCSDK
#include "tier0/memdbgoff.h"
#endif //SHAREDOBJECT_H