physicallayer/persist.h

/*
    Crystal Space Entity Layer
    Copyright (C) 2001 by Jorrit Tyberghein
  
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
  
    This library 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
    Library General Public License for more details.
  
    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
    MA 02111-1307, USA.
*/

#ifndef __CEL_PL_PERSIST__
#define __CEL_PL_PERSIST__

#include "cstypes.h"
#include "csutil/scf.h"
#include "csutil/util.h"
#include "csutil/array.h"

#include "physicallayer/datatype.h"

struct iCelPropertyClass;
struct iCelEntity;
struct iFile;
struct celData;

enum celPersistenceType
{
  CEL_PERSIST_TYPE_UNDEF = 0,
  CEL_PERSIST_TYPE_RECORD,
  CEL_PERSIST_TYPE_RECORD_FIRST_PASS,
  CEL_PERSIST_TYPE_SERVER_CONTROL,
  CEL_PERSIST_TYPE_CLIENT_CONTROL,
  CEL_PERSIST_TYPE_SERVER_FORCING
};

enum celPersistenceResult
{
  CEL_PERSIST_RESULT_UNDEF = 0,
  CEL_PERSIST_RESULT_OK,
  CEL_PERSIST_RESULT_CHEAT_SUSPICIOUS,
  CEL_PERSIST_RESULT_CHEAT_CLEAR,
  CEL_PERSIST_RESULT_ERROR,
  CEL_PERSIST_RESULT_UNKNOWN_PC
};

struct iCelDataBuffer : public virtual iBase
{
  SCF_INTERFACE (iCelDataBuffer, 0, 0, 2);

  virtual long GetSerialNumber () const = 0;

  virtual size_t GetDataCount () const = 0;

  virtual void Reset () = 0;

  virtual celData* GetData () = 0;

  virtual celData* GetData (size_t idx) = 0;

  virtual celData* AddData () = 0;

  virtual void Add (bool v) { AddData ()->Set (v); }
  virtual void Add (int8 v) { AddData ()->Set (v); }
  virtual void Add (int16 v) { AddData ()->Set (v); }
  virtual void Add (int32 v) { AddData ()->Set (v); }
  virtual void Add (uint8 v) { AddData ()->Set (v); }
  virtual void Add (uint16 v) { AddData ()->Set (v); }
  virtual void Add (uint32 v) { AddData ()->Set (v); }
  virtual void Add (float v) { AddData ()->Set (v); }
  virtual void Add (const csVector2& v) { AddData ()->Set (v); }
  virtual void Add (const csVector3& v) { AddData ()->Set (v); }
  virtual void Add (const csColor& v) { AddData ()->Set (v); }
  virtual void Add (const char* v) { AddData ()->Set (v); }
  virtual void Add (iCelPropertyClass* v) { AddData ()->Set (v); }
  virtual void Add (iCelEntity* v) { AddData ()->Set (v); }
  virtual void AddAction (const char* v) { AddData ()->SetAction (v); }
  virtual void AddIBase (iBase* v) { AddData ()->SetIBase (v); }

  virtual bool GetBool ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_BOOL) ? cd->value.bo : false;
  }
  virtual int8 GetInt8 ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_BYTE) ? cd->value.b : 0;
  }
  virtual uint8 GetUInt8 ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_UBYTE) ? cd->value.ub : 0;
  }
  virtual int16 GetInt16 ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_WORD) ? cd->value.w : 0;
  }
  virtual uint16 GetUInt16 ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_UWORD) ? cd->value.uw : 0;
  }
  virtual int32 GetInt32 ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_LONG) ? cd->value.l : 0;
  }
  virtual uint32 GetUInt32 ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_ULONG) ? cd->value.ul : 0;
  }
  virtual float GetFloat ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_FLOAT) ? cd->value.f : 0.0f;
  }
  virtual iString* GetString ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_STRING) ? cd->value.s : (iString*)0;
  }
  virtual void GetVector2 (csVector2& v)
  {
    celData* cd = GetData ();
    if (cd && cd->type == CEL_DATA_VECTOR2)
    { v.x = cd->value.v.x; v.y = cd->value.v.y; }
    else v.x = v.y = 0;
  }
  virtual void GetVector3 (csVector3& v)
  {
    celData* cd = GetData ();
    if (cd && cd->type == CEL_DATA_VECTOR3)
    { v.x = cd->value.v.x; v.y = cd->value.v.y; v.z = cd->value.v.z; }
    else v.x = v.y = v.z = 0;
  }
  virtual void GetColor (csColor& v)
  {
    celData* cd = GetData ();
    if (cd && cd->type == CEL_DATA_COLOR)
    {
      v.red = cd->value.col.red;
      v.green = cd->value.col.green;
      v.blue = cd->value.col.blue;
    }
    else v.red = v.green= v.blue = 0;
  }
  virtual iCelPropertyClass* GetPC ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_PCLASS)
        ? cd->value.pc
        : (iCelPropertyClass*)0;
  }
  virtual iCelEntity* GetEntity ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_ENTITY)
        ? cd->value.ent
        : (iCelEntity*)0;
  }
  virtual iBase* GetIBase ()
  {
    celData* cd = GetData ();
    return (cd && cd->type == CEL_DATA_IBASE) ? cd->value.ibase : (iBase*)0;
  }
  virtual csString GetDebugInfo ()
  {
    if (GetDataCount () == 0) return "Data buffer: empty\n";

    csString txt = "Data buffer:\n";
    size_t i = 0, count = GetDataCount ();
    for ( ; i < count; i++)
      txt.AppendFmt("\t%s\n", GetData (i)->GetDebugInfo ().GetData ());

    return txt;
  }
};

struct iCelPersistentDataList : public virtual iBase
{
  SCF_INTERFACE (iCelPersistentDataList, 0, 0, 1);

  virtual size_t GetCount () const = 0;

  virtual bool GetPersistentData (size_t idx, csRef<iCelDataBuffer>& databuf, 
        csString& pc_name, csString& pc_tag) const = 0;

  virtual void AddPersistentData (csRef<iCelDataBuffer>& databuf, 
        csString& pc_name, csString& pc_tag) = 0;
};

struct iCelLocalEntitySet : public virtual iBase
{
  SCF_INTERFACE (iCelLocalEntitySet, 0, 0, 1);

  virtual size_t GetEntityCount () const = 0;
  
  virtual iCelEntity* GetEntity (size_t idx) const = 0;

  virtual void AddEntity (iCelEntity* entity) = 0;

  virtual bool IsLocal (iCelEntity* entity) = 0;
  virtual bool IsLocal (iCelPropertyClass* pc) = 0;

  virtual csPtr<iCelDataBuffer> SaveExternalEntity (iCelEntity* entity) = 0;

  virtual iCelEntity* FindExternalEntity (iCelDataBuffer* databuf) = 0;

  virtual csPtr<iCelDataBuffer> SaveExternalPC (iCelPropertyClass* pc) = 0;

  virtual iCelPropertyClass* FindExternalPC (iCelDataBuffer* databuf) = 0;
};

struct iCelPersistence : public virtual iBase
{
  SCF_INTERFACE (iCelPersistence, 0, 1, 1);

  virtual bool Load (iCelLocalEntitySet* set, const char* name) = 0;

  virtual bool Save (iCelLocalEntitySet* set, const char* name) = 0;

  virtual bool Load (iCelLocalEntitySet* set, iFile* file) = 0;

  virtual bool Save (iCelLocalEntitySet* set, iFile* file) = 0;
};

#endif // __CEL_PL_PERSIST__