CWE-ou-minkata/Sources/Plasma/PubUtilLib/plSDL/plSDLDescriptor.h

/*==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 plSDL_DESC_inc
#define plSDL_DESC_inc

//
// Code for State Description Language (SDL) Descriptors.
// These define a schema representing an object's saveState buffer.
//

#include "hsTypes.h"
#include "hsUtils.h"
#include "hsStlUtils.h"

//
// Describes a variable in a state descriptor.
// Every variable is actually a list, either fixed or variable length.
// Abstract base class.
//
class hsStream;
class plSimpleVarDescriptor;
class plSDVarDescriptor;
class plVarDescriptor
{
public:
    enum Type
    {
        kNone   = -1,

        // atomic types
        kInt,
        kFloat,
        kBool,
        kString32,
        kKey,       // plKey - basically a uoid
        kStateDescriptor,   // this var refers to another state descriptor
        kCreatable, // plCreatable - basically a classIdx and a read/write buffer
        kDouble,
        kTime,      // double which is automatically converted to server clock and back, use for animation times
        kByte,
        kShort,
        kAgeTimeOfDay,  // float which is automatically set to the current age time of day (0-1)
        
        // the following are a vector of floats
        kVector3=50,// atomicCount=3
        kPoint3,    // atomicCount=3
        kRGB,       // atomicCount=3
        kRGBA,      // atomicCount=4
        kQuaternion,    // atomicCount=4
        kRGB8,      // atomicCount=3
        kRGBA8,     // atomicCount=4
    };
    typedef char String32[32];
    
    enum Flags
    {
        kInternal   = 0x1,      // Don't allow access to this var in Vault Mgr
        kAlwaysNew  = 0x2,      // Treat this var as always having the latest timestamp when FlaggingNewerState
        kVariableLength = 0x4   // Var is defined as int foo[], so it's length is variable, starting at 0
    };
protected:
    static const UInt8 kVersion;    // for Read/Write format
    char*   fDefault;               // set by .sdl
    char*   fName;                  // set by .sdl
    int     fCount;                 // set by .sdl
    Type    fType;                  // set by .sdl
    char*   fTypeString;            // string version of fType
    UInt32  fFlags;
    std::string fDisplayOptions;    // set by .sdl
public:
    plVarDescriptor();
    virtual ~plVarDescriptor();
    
    virtual void CopyFrom(const plVarDescriptor* v);
    
    // conversion ops
    virtual plSimpleVarDescriptor*  GetAsSimpleVarDescriptor() = 0;
    virtual plSDVarDescriptor* GetAsSDVarDescriptor() = 0;
    virtual const plSimpleVarDescriptor*    GetAsSimpleVarDescriptor() const = 0;
    virtual const plSDVarDescriptor* GetAsSDVarDescriptor() const = 0;

    // getters
    const char* GetDefault()    const   { return fDefault; }
    const char* GetName()   const       { return fName; }
    Type    GetType() const             { return fType; }
    const char* GetTypeString() const   { return fTypeString; }
    int     GetCount() const            { return fCount; }
    bool    IsInternal() const          { return (fFlags & kInternal) != 0; }
    bool    IsAlwaysNew() const         { return (fFlags & kAlwaysNew) != 0; }
    bool    IsVariableLength() const    { return (fFlags & kVariableLength) != 0; }
    const char* GetDisplayOptions() const { return fDisplayOptions.c_str(); }
    
    // setters
    void    SetDefault(const char* n)   { delete [] fDefault; fDefault= hsStrcpy(n); }
    void    SetName(const char* n)      { delete [] fName; fName = hsStrcpy(n); }
    void    SetCount(int c)             { fCount=c; }
    virtual bool    SetType(const char* type);
    void    SetType(Type t) { fType=t; }
    void    SetInternal(bool d)         { if (d) fFlags |= kInternal; else fFlags &= ~kInternal; }
    void    SetAlwaysNew(bool d)        { if (d) fFlags |= kAlwaysNew; else fFlags &= ~kAlwaysNew; }
    void    SetVariableLength(bool d)   { if (d) fFlags |= kVariableLength; else fFlags &= ~kVariableLength; }
    void    SetDisplayOptions(const char* s) { fDisplayOptions=s;   }

    // IO
    virtual bool    Read(hsStream* s);  
    virtual void    Write(hsStream* s) const;
};

//
// Simple, non-nested var descriptors.  These are comprised of single types, as opposed to 
// referring to another state descriptor.
//
class plSimpleVarDescriptor : public plVarDescriptor
{
protected:
    Type    fAtomicType;            // base type (it. quaternion == kFloat)
    int     fAtomicCount;           // computed from type in .sdl (ie. quaternion == 4)
public:
    plSimpleVarDescriptor();
    virtual ~plSimpleVarDescriptor() {  }
        
    plSimpleVarDescriptor*  GetAsSimpleVarDescriptor() { return this; }
    plSDVarDescriptor* GetAsSDVarDescriptor() { return nil; }
    const plSimpleVarDescriptor*    GetAsSimpleVarDescriptor() const { return this; }
    const plSDVarDescriptor* GetAsSDVarDescriptor() const { return nil; }

    void CopyFrom(const plSimpleVarDescriptor* v);
    void CopyFrom(const plVarDescriptor* v) { plVarDescriptor::CopyFrom(v); }   // lame compiler

    // getters
    int     GetSize() const;
    int     GetAtomicSize() const;      // size of one item in bytes (regardless of count)
    Type    GetAtomicType() const       { return fAtomicType; }
    int     GetAtomicCount() const      { return fAtomicCount; }    
    
    // setters
    bool    SetType(const char* type);
    void    SetType(Type t) { plVarDescriptor::SetType(t); }    // for lame compiler
    void    SetAtomicType(Type t) { fAtomicType=t; }    

    // IO
    virtual bool    Read(hsStream* s);  
    virtual void    Write(hsStream* s) const;
};

//
// A var descriptor which references another state descriptor.
//
class plStateDescriptor;
class plSDVarDescriptor : public plVarDescriptor
{
protected:
    plStateDescriptor* fStateDesc;      
public:
    plSDVarDescriptor(plStateDescriptor* sd=nil) : fStateDesc(sd) { }

    plSimpleVarDescriptor*  GetAsSimpleVarDescriptor() { return nil; }
    plSDVarDescriptor* GetAsSDVarDescriptor() { return this; }
    const plSimpleVarDescriptor*    GetAsSimpleVarDescriptor() const { return nil; }
    const plSDVarDescriptor* GetAsSDVarDescriptor() const { return this; }

    // getters
    plStateDescriptor* GetStateDescriptor() const { return fStateDesc; }

    // setters
    void SetStateDesc(plStateDescriptor* sd) { fStateDesc=sd; }

    void CopyFrom(const plSDVarDescriptor* v);
    void CopyFrom(const plVarDescriptor* v) { plVarDescriptor::CopyFrom(v); }   // lame compiler

    // IO
    bool    Read(hsStream* s);  
    void    Write(hsStream* s) const;
};

//
// A state descriptor - describes the contents of a type of state buffer.
// There is one of these for each persistent object type.
// These descriptors are defined in a user-created .sdl file.
//
class plKey;
class plStateDescriptor
{
private:
    static const UInt8 kVersion;        // for Read/Write format
    typedef std::vector<plVarDescriptor*> VarsList; 
    VarsList fVarsList;
    int fVersion;
    char* fName;
    std::string fFilename;  // the filename this descriptor was read from

    void IDeInit();
public:
    plStateDescriptor() : fVersion(-1),fName(nil) {}
    ~plStateDescriptor(); 

    // getters
    const char* GetName() const { return fName; }
    int GetNumVars() const { return fVarsList.size(); }
    plVarDescriptor* GetVar(int i) const { return fVarsList[i]; }
    int GetVersion() const { return fVersion; }
    const char * GetFilename() const { return fFilename.c_str();}
    
    // setters
    void SetVersion(int v) { fVersion=v; }
    void SetName(const char* n) { delete [] fName; fName=hsStrcpy(n); }
    void AddVar(plVarDescriptor* v) { fVarsList.push_back(v); }
    void SetFilename( const char * n ) { fFilename=n;}
    
    plVarDescriptor* FindVar(const char* name, int* idx=nil) const;

    // IO
    bool Read(hsStream* s); 
    void Write(hsStream* s) const;
};

#endif  // plSDL_DESC_inc