You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

552 lines
22 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#ifndef PL_SDL_inc
#define PL_SDL_inc
//
// Code for the State Description Language (SDL)
//
#include "plSDLDescriptor.h"
#include "hsUtils.h"
#include "hsStlUtils.h"
#include "../pnFactory/plCreatable.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnKeyedObject/plUoid.h"
#include "../plUnifiedTime/plUnifiedTime.h"
namespace plSDL
{
typedef std::list<plStateDescriptor*> DescriptorList;
enum GeneralPurpose
{
kLatestVersion = -1, // used when requesting the latest version of a state descriptor
kMaxListSize = 9999 // maximum size of var lists
};
enum ContentsFlags // or saveFlags, 16 bits
{
kHasUoid = 0x1,
kHasNotificationInfo = 0x2,
kHasTimeStamp = 0x4,
kSameAsDefault = 0x8,
kHasDirtyFlag = 0x10,
kWantTimeStamp = 0x20,
kAddedVarLengthIO = 0x8000, // using to establish a new version in the header, can delete in 8/03
kHasMaximumValue= 0xffff,
};
enum RWOptions
{
kDirtyOnly = 1<< 0, // write option
kSkipNotificationInfo = 1<< 1, // read/write option
kBroadcast = 1<< 2, // send option
kWriteTimeStamps = 1<< 3, // write out time stamps
kTimeStampOnRead = 1<< 4, // read: timestamp each var when it gets read. write: request that the reader timestamp the dirty vars.
kTimeStampOnWrite = 1<< 5, // read: n/a. write: timestamp each var when it gets written.
kKeepDirty = 1<< 6, // don't clear dirty flag on read
kDontWriteDirtyFlag = 1<< 7, // write option. don't write var dirty flag.
kMakeDirty = 1<< 8, // read/write: set dirty flag on var read/write.
kDirtyNonDefaults = 1<< 9, // dirty the var if non default value.
kForceConvert = 1<<10, // always try to convert rec to latest on read
};
enum BehaviorFlags
{
kDisallowTimeStamping = 0x1,
};
extern const char* kAgeSDLObjectName;
void VariableLengthRead(hsStream* s, int size, int* val);
void VariableLengthWrite(hsStream* s, int size, int val);
};
class plStateVarNotificationInfo
{
private:
std::string fHintString;
public:
void SetHintString(const char* c) { fHintString=c; }
const char* GetHintString() const { return fHintString.c_str(); }
void Read(hsStream* s, UInt32 readOptions);
void Write(hsStream* s, UInt32 writeOptions) const;
};
//
// Base class for a state variable.
// A state var is a var descriptor and it's value (contents)
//
class plSimpleStateVariable;
class plSDStateVariable;
class plStateVariable
{
public:
enum Flags
{
kDirty = 0x1, // true when someone sets the value using Set(...), can be cleared after writing
kUsed = 0x2 // true when it contains some value (either by Set(...) or Read() )
};
protected:
UInt32 fFlags;
plStateVarNotificationInfo fNotificationInfo;
public:
plStateVariable() : fFlags(0) {}
virtual ~plStateVariable() {}
const char* GetName() const { return GetVarDescriptor()->GetName(); }
bool IsNamed(const char* n) const { return (n && !stricmp(GetName(), n)); }
virtual int GetCount() const = 0;
// conversion ops
virtual plSimpleStateVariable* GetAsSimpleStateVar() = 0;
virtual plSDStateVariable* GetAsSDStateVar() = 0;
virtual plVarDescriptor* GetVarDescriptor() = 0;
virtual const plVarDescriptor* GetVarDescriptor() const = 0;
virtual void Alloc(int cnt=-1 /* -1 means don't change count */) = 0;
virtual bool IsDirty() const { return (fFlags & kDirty) != 0; }
virtual bool IsUsed() const { return (fFlags & kUsed) != 0; }
void SetDirty(bool d) { if (d) fFlags |= kDirty; else fFlags &= ~kDirty; }
void SetUsed(bool d) { if (d) fFlags |= kUsed; else fFlags &= ~kUsed; }
virtual void SetFromDefaults(bool timeStampNow) = 0;
virtual void TimeStamp( const plUnifiedTime & ut=plUnifiedTime::GetCurrentTime() ) = 0;
virtual const plUnifiedTime& GetTimeStamp() const = 0;
plStateVarNotificationInfo& GetNotificationInfo() { return fNotificationInfo; }
const plStateVarNotificationInfo& GetNotificationInfo() const { return fNotificationInfo; }
virtual void DumpToObjectDebugger(bool dirtyOnly, int level) const {}
virtual void DumpToStream(hsStream* stream, bool dirtyOnly, int level) const {}
// IO
virtual bool ReadData(hsStream* s, float timeConvert, UInt32 readOptions);
virtual bool WriteData(hsStream* s, float timeConvert, UInt32 writeOptions) const;
};
//
// Change Notifier.
// When a plSimpleStateVariable changes it's value by more than the given delta value,
// a notification msg will be sent to the objects that registered interest.
//
class plStateChangeNotifier
{
friend class plSimpleStateVariable;
private:
float fDelta;
typedef std::vector<plKey> KeyList;
KeyList fKeys; // the objects to notify on change>delta
static UInt32 fCurrentPlayerID;
void IAddKey(plKey k);
int IRemoveKey(plKey k);
public:
plStateChangeNotifier();
plStateChangeNotifier(float i, plKey k);
void AddNotificationKey(plKey k) { IAddKey(k); }
void AddNotificationKeys(KeyList keys);
int RemoveNotificationKey(plKey k); // returns number of keys left after removal
int RemoveNotificationKeys(KeyList keys); // returns number of keys left after removal
void SendNotificationMsg(const plSimpleStateVariable* srcVar, const plSimpleStateVariable* dstVar, const char* sdlName);
bool GetValue(float* i) const;
bool SetValue(float i);
static UInt32 GetCurrentPlayerID() { return fCurrentPlayerID; }
static void SetCurrentPlayerID(UInt32 p) { fCurrentPlayerID=p; }
bool operator==(const plStateChangeNotifier &) const;
};
//
// A (non-nested) variable descriptor and its data contents.
//
class plUoid;
class plKey;
class plClientUnifiedTime;
typedef unsigned char byte;
class plSimpleStateVariable : public plStateVariable
{
protected:
union
{
int* fI; // array of int
short* fS; // array of short
byte* fBy; // array of byte
float* fF; // array of float
double* fD; // array of double
bool* fB; // array of bool
plUoid* fU; // array of uoid
plCreatable** fC; // array of plCreatable ptrs
plVarDescriptor::String32* fS32; // array of strings
plClientUnifiedTime* fT; // array of Times
};
mutable plUnifiedTime fTimeStamp; // the last time the var was changed
plSimpleVarDescriptor fVar;
typedef std::vector<plStateChangeNotifier> StateChangeNotifiers;
StateChangeNotifiers fChangeNotifiers;
void IDeAlloc();
void IInit(); // initize vars
void IVarSet(bool timeStampNow=false);
// converter fxns
bool IConvertFromBool(plVarDescriptor::Type newType);
bool IConvertFromInt(plVarDescriptor::Type newType);
bool IConvertFromByte(plVarDescriptor::Type newType);
bool IConvertFromShort(plVarDescriptor::Type newType);
bool IConvertFromFloat(plVarDescriptor::Type newType);
bool IConvertFromDouble(plVarDescriptor::Type newType);
bool IConvertFromString(plVarDescriptor::Type newType);
bool IConvertFromRGB(plVarDescriptor::Type newType);
bool IConvertFromRGBA(plVarDescriptor::Type newType);
bool IConvertFromRGB8(plVarDescriptor::Type newType);
bool IConvertFromRGBA8(plVarDescriptor::Type newType);
bool IReadData(hsStream* s, float timeConvert, int idx, UInt32 readOptions);
bool IWriteData(hsStream* s, float timeConvert, int idx, UInt32 writeOptions) const;
public:
plSimpleStateVariable() { IInit(); }
plSimpleStateVariable(plVarDescriptor* vd) { IInit(); CopyFrom(vd); }
~plSimpleStateVariable() { IDeAlloc(); }
// conversion ops
plSimpleStateVariable* GetAsSimpleStateVar() { return this; }
plSDStateVariable* GetAsSDStateVar() { return nil; }
bool operator==(const plSimpleStateVariable &other) const; // assumes matching var descriptors
void TimeStamp( const plUnifiedTime & ut=plUnifiedTime::GetCurrentTime() );
void CopyFrom(plVarDescriptor* v);
void CopyData(const plSimpleStateVariable* other, UInt32 writeOptions=0);
bool SetFromString(const char* value, int idx, bool timeStampNow); // set value from string, type. return false on err
char* GetAsString(int idx) const;
bool ConvertTo(plSimpleVarDescriptor* toVar, bool force=false); // return false on err
void Alloc(int cnt=-1 /* -1 means don't change count */); // alloc memory after setting type
void Reset();
// setters
bool Set(float v, int idx=0);
bool Set(float* v, int idx=0); // floatVector
bool Set(double v, int idx=0);
bool Set(double* v, int idx=0); // doubleVector
bool Set(int v, int idx=0);
bool Set(int* v, int idx=0) { return Set(*v, idx); } // helper since there is no int vec type
bool Set(byte v, int idx=0);
bool Set(byte* v, int idx=0); // byteVector
bool Set(short v, int idx=0);
bool Set(short* v, int idx=0) { return Set(*v, idx); } // helper since there is no short vec type
bool Set(bool v, int idx=0);
bool Set(bool* v, int idx=0) { return Set(*v, idx); } // helper since there is no bool vec type
bool Set(const char* v, int idx=0); // string
bool Set(const plKey& v, int idx=0);
bool Set(plCreatable*, int idx=0); // only SDL generated by the server is allowed to use this type.
void SetFromDefaults(bool timeStampNow);
// getters
bool Get(int* value, int idx=0) const;
bool Get(short* value, int idx=0) const;
bool Get(byte* value, int idx=0) const; // returns byte or byteVector
bool Get(float* value, int idx=0) const; // returns float or floatVector
bool Get(double* value, int idx=0) const; // returns double or doubleVector
bool Get(bool* value, int idx=0) const;
bool Get(char value[], int idx=0) const;
bool Get(plKey* value, int idx=0) const;
bool Get(plCreatable** value, int idx=0) const;
const plUnifiedTime& GetTimeStamp() const { return fTimeStamp; }
// Special backdoor so the KI Manager can get the key name without having a ResMgr
const char* GetKeyName(int idx=0) const;
int GetCount() const { return fVar.GetCount(); } // helper
plVarDescriptor* GetVarDescriptor() { return &fVar; }
plSimpleVarDescriptor* GetSimpleVarDescriptor() { return fVar.GetAsSimpleVarDescriptor(); }
const plVarDescriptor* GetVarDescriptor() const { return &fVar; }
const plSimpleVarDescriptor* GetSimpleVarDescriptor() const { return fVar.GetAsSimpleVarDescriptor(); }
// State Change Notification
void AddStateChangeNotification(plStateChangeNotifier& n);
void RemoveStateChangeNotification(plKey notificationObj); // remove all with this key
void RemoveStateChangeNotification(plStateChangeNotifier n); // remove ones which match
void NotifyStateChange(const plSimpleStateVariable* other, const char* sdlName); // send notification msg if necessary, internal use
void DumpToObjectDebugger(bool dirtyOnly, int level) const;
void DumpToStream(hsStream* stream, bool dirtyOnly, int level) const;
// IO
bool ReadData(hsStream* s, float timeConvert, UInt32 readOptions);
bool WriteData(hsStream* s, float timeConvert, UInt32 writeOptions) const;
};
//
// A list of state data records, all of which are the same kind.
// Corresponds to a SD var descriptor.
//
class plStateDataRecord;
class plSDStateVariable : public plStateVariable
{
public:
typedef std::vector<const plStateDataRecord*> ConstDataRecList;
protected:
typedef std::vector<plStateDataRecord*> DataRecList;
DataRecList fDataRecList;
plSDVarDescriptor* fVarDescriptor;
void IDeInit();
public:
plSDStateVariable(plSDVarDescriptor* sdvd);
~plSDStateVariable(); // delete all records
// conversion ops
plSimpleStateVariable* GetAsSimpleStateVar() { return nil; }
plSDStateVariable* GetAsSDStateVar() { return this; }
bool operator==(const plSDStateVariable &other) const; // assumes matching var descriptors
void ConvertTo(plSDStateVariable* otherSDVar, bool force=false);
void CopyFrom(plSDStateVariable* other, UInt32 writeOptions=0);
void UpdateFrom(plSDStateVariable* other, UInt32 writeOptions=0);
void AddStateDataRecord(plStateDataRecord *sdr) { fDataRecList.push_back(sdr); SetDirty(true); SetUsed(true); }
void InsertStateDataRecord(plStateDataRecord *sdr, int i) { fDataRecList[i] = sdr; SetDirty(true); SetUsed(true);}
void SetFromDefaults(bool timeStampNow);
void TimeStamp( const plUnifiedTime & ut=plUnifiedTime::GetCurrentTime() );
const plUnifiedTime& GetTimeStamp() const { static plUnifiedTime foo; return foo; }
void Alloc(int cnt=-1 /* -1 means don't change count */); // wipe and re-create
void Alloc(plSDVarDescriptor* sdvd, int cnt=-1); // wipe and re-create
void Resize(int cnt);
bool IsDirty() const;
bool IsUsed() const;
// getters
plStateDataRecord* GetStateDataRecord(int i) { return fDataRecList[i]; }
const plStateDataRecord* GetStateDataRecord(int i) const { return fDataRecList[i]; }
int GetCount() const { return fDataRecList.size(); }
int GetUsedCount() const;
int GetDirtyCount() const;
void GetUsedDataRecords(ConstDataRecList*) const;
void GetDirtyDataRecords(ConstDataRecList*) const;
plVarDescriptor* GetVarDescriptor() { return fVarDescriptor; }
plSDVarDescriptor* GetSDVarDescriptor() { return fVarDescriptor->GetAsSDVarDescriptor(); }
const plVarDescriptor* GetVarDescriptor() const { return fVarDescriptor; }
const plSDVarDescriptor* GetSDVarDescriptor() const { return fVarDescriptor->GetAsSDVarDescriptor(); }
void FlagNewerState(const plSDStateVariable&, bool respectAlwaysNew);
void FlagAlwaysNewState();
void DumpToObjectDebugger(bool dirtyOnly, int level) const;
void DumpToStream(hsStream* stream, bool dirtyOnly, int level) const;
// IO
bool ReadData(hsStream* s, float timeConvert, UInt32 readOptions);
bool WriteData(hsStream* s, float timeConvert, UInt32 writeOptions) const;
};
//
// Contains the actual data contents and points to its associated descriptor
//
class plNetMsgSDLState;
class plStateDataRecord : public plCreatable
{
public:
typedef std::vector<plSimpleStateVariable*> SimpleVarsList;
typedef std::vector<plSDStateVariable*> SDVarsList;
enum Flags
{
kVolatile = 0x1
};
protected:
typedef std::vector<plStateVariable*> VarsList;
const plStateDescriptor* fDescriptor;
plUoid fAssocObject; // optional
VarsList fVarsList; // list of variables
VarsList fSDVarsList; // list of nested data records
UInt32 fFlags;
static const UInt8 kIOVersion; // I/O Version
void IDeleteVarsList(VarsList& vars);
void IInitDescriptor(const char* name, int version); // or plSDL::kLatestVersion
void IInitDescriptor(const plStateDescriptor* sd);
void IReadHeader(hsStream* s);
void IWriteHeader(hsStream* s) const;
bool IConvertVar(plSimpleStateVariable* fromVar, plSimpleStateVariable* toVar, bool force);
plStateVariable* IFindVar(const VarsList& vars, const char* name) const;
int IGetNumUsedVars(const VarsList& vars) const;
int IGetUsedVars(const VarsList& varsOut, VarsList *varsIn) const; // build a list of vars that have data
bool IHasUsedVars(const VarsList& vars) const;
int IGetNumDirtyVars(const VarsList& vars) const;
int IGetDirtyVars(const VarsList& varsOut, VarsList *varsIn) const; // build a list of vars that are dirty
bool IHasDirtyVars(const VarsList& vars) const;
public:
CLASSNAME_REGISTER( plStateDataRecord );
GETINTERFACE_ANY( plStateDataRecord, plCreatable);
plStateDataRecord(const char* sdName, int version=plSDL::kLatestVersion);
plStateDataRecord(plStateDescriptor* sd);
plStateDataRecord(const plStateDataRecord &other, UInt32 writeOptions=0 ):fFlags(0) { CopyFrom(other, writeOptions); }
plStateDataRecord():fFlags(0) {}
~plStateDataRecord();
bool ConvertTo(plStateDescriptor* other, bool force=false );
bool operator==(const plStateDataRecord &other) const; // assumes matching state descriptors
UInt32 GetFlags() const { return fFlags; }
void SetFlags(UInt32 f) { fFlags =f; }
plSimpleStateVariable* FindVar(const char* name) const { return (plSimpleStateVariable*)IFindVar(fVarsList, name); }
plSDStateVariable* FindSDVar(const char* name) const { return (plSDStateVariable*)IFindVar(fSDVarsList, name); }
plStateDataRecord& operator=(const plStateDataRecord& other) { CopyFrom(other); }
void CopyFrom(const plStateDataRecord& other, UInt32 writeOptions=0);
void UpdateFrom(const plStateDataRecord& other, UInt32 writeOptions=0);
void SetFromDefaults(bool timeStampNow);
void TimeStampDirtyVars();
int GetNumVars() const { return fVarsList.size(); }
plSimpleStateVariable* GetVar(int i) const { return (plSimpleStateVariable*)fVarsList[i]; }
int GetNumSDVars() const { return fSDVarsList.size(); }
plSDStateVariable* GetSDVar(int i) const { return (plSDStateVariable*)fSDVarsList[i]; }
// Used vars
bool IsUsed() const { return (HasUsedVars() || HasUsedSDVars()); }
int GetNumUsedVars() const { return IGetNumUsedVars(fVarsList); }
int GetUsedVars(SimpleVarsList *vars) const { return IGetUsedVars(fVarsList, (VarsList*)vars); } // build a list of vars that have data
bool HasUsedVars() const { return IHasUsedVars(fVarsList); }
int GetNumUsedSDVars() const { return IGetNumUsedVars(fSDVarsList); }
int GetUsedSDVars(SDVarsList *vars) const { return IGetUsedVars(fSDVarsList, (VarsList*)vars); } // build a list of SD vars that have data
bool HasUsedSDVars() const { return IHasUsedVars(fSDVarsList); }
// Dirty Vars
bool IsDirty() const { return (HasDirtyVars() || HasDirtySDVars()); }
int GetNumDirtyVars() const { return IGetNumDirtyVars(fVarsList); }
int GetDirtyVars(SimpleVarsList *vars) const { return IGetDirtyVars(fVarsList, (VarsList*)vars); } // build a list of vars that are dirty
bool HasDirtyVars() const { return IHasDirtyVars(fVarsList); }
int GetNumDirtySDVars() const { return IGetNumDirtyVars(fSDVarsList); }
int GetDirtySDVars(SDVarsList *vars) const { return IGetDirtyVars(fSDVarsList, (VarsList*)vars); }; // build a list of Sdvars that are dirty
bool HasDirtySDVars() const { return IHasDirtyVars(fSDVarsList); }
const plStateDescriptor* GetDescriptor() const { return fDescriptor; }
void SetDescriptor(const char* sdName, int version);
plNetMsgSDLState* PrepNetMsg(float timeConvert, UInt32 writeOptions) const; // create/prep a net msg with this data
void SetAssocObject(const plUoid& u) { fAssocObject=u; } // optional
plUoid* GetAssocObject() { return &fAssocObject; } // optional
const plUoid* GetAssocObject() const { return &fAssocObject; } // optional
// utils
void FlagDifferentState(const plStateDataRecord& other); // mark items which differ from 'other' as dirty
void FlagNewerState(const plStateDataRecord& other, bool respectAlwaysNew=false); // mark items which are newer than 'other' as dirty
void FlagAlwaysNewState(); // mark 'alwaysNew' items as dirty
void DumpToObjectDebugger(const char* msg, bool dirtyOnly=false, int level=0) const;
void DumpToStream(hsStream* stream, const char* msg, bool dirtyOnly=false, int level=0) const;
// IO
bool Read(hsStream* s, float timeConvert, UInt32 readOptions=0);
void Write(hsStream* s, float timeConvert, UInt32 writeOptions=0) const;
static bool ReadStreamHeader(hsStream* s, char** name, int* version, plUoid* objUoid=nil);
void WriteStreamHeader(hsStream* s, plUoid* objUoid=nil) const;
};
//
// Simple SDL parser
//
class plSDLMgr;
class plSDLParser
{
private:
bool IReadDescriptors() const;
bool ILoadSDLFile(const char* fileName) const;
bool IParseVarDesc(const char* fileName, hsStream* stream, char token[], plStateDescriptor*& curDesc,
plVarDescriptor*& curVar) const;
bool IParseStateDesc(const char* fileName, hsStream* stream, char token[], plStateDescriptor*& curDesc) const;
void DebugMsg(char* fmt, ...) const;
void DebugMsgV(char* fmt, va_list args) const;
public:
bool Parse() const; // reads sdl folder, creates descriptor list
};
//
// Holds, loads and unloads all state descriptors from sdl files.
// Singleton.
//
class plNetApp;
class plSDLMgr
{
friend class plSDLParser;
private:
std::string fSDLDir;
plSDL::DescriptorList fDescriptors;
plNetApp* fNetApp;
UInt32 fBehaviorFlags;
void IDeleteDescriptors(plSDL::DescriptorList* dl);
public:
plSDLMgr();
~plSDLMgr();
static plSDLMgr* GetInstance();
plStateDescriptor* FindDescriptor(const char* name, int version, const plSDL::DescriptorList * dl=nil) const; // version or kLatestVersion
const plSDL::DescriptorList * GetDescriptors( void ) const { return &fDescriptors;}
void SetSDLDir(const char* s) { fSDLDir=s; }
const char* GetSDLDir() const { return fSDLDir.c_str(); }
void SetNetApp(plNetApp* a) { fNetApp=a; }
plNetApp* GetNetApp() const { return fNetApp; }
bool Init( UInt32 behaviorFlags=0 ); // parse sdl folder
void DeInit();
UInt32 GetBehaviorFlags() const { return fBehaviorFlags; }
void SetBehaviorFlags(UInt32 v) { fBehaviorFlags=v; }
bool AllowTimeStamping() const { return ! ( fBehaviorFlags&plSDL::kDisallowTimeStamping ); }
// I/O - return # of bytes read/written
int Write(hsStream* s, const plSDL::DescriptorList* dl=nil); // write descriptors to a stream
int Read(hsStream* s, plSDL::DescriptorList* dl=nil); // read descriptors into provided list (use legacyList if nil)
};
#endif // PL_SDL_inc