prj/cam/h/persist.h

   1 /*
   2 @Copyright Looking Glass Studios, Inc.
   3 1996,1997,1998,1999,2000 Unpublished Work.
   4 */
   5
   6 ///////////////////////////////////////////////////////////////////////////////
   7 // $Header: r:/t2repos/thief2/libsrc/script/persist.h,v 1.2 1999/06/29 19:10:57 mahk Exp $
   8 //
   9 // sPersistent is a weird little utility struct for loading and
  10 // saving the basic types used by scripts, including vectors and
  11 // cMultiParms.
  12 //
  13 // A struct or class which wants to be persistent should descend
  14 // from sPersistent.  For the sake of one of our macros, it will
  15 // also want a default constructor.
  16
  17 #ifndef __PERSIST_H
  18 #define __PERSIST_H
  19
  20 #pragma once
  21
  22
  23 #define kPersistNameMax 31
  24
  25
  26 typedef int (*tPersistIOFunc)(void * pContext, void * p, size_t size);
  27
  28
  29 struct sPersistent
  30 {
  31    virtual ~sPersistent() { };
  32
  33    BOOL ReadWrite(tPersistIOFunc pfnIO, void * pContextIO, BOOL fReading);
  34    BOOL Reading() { return gm_fReading; };
  35
  36    BOOL Persistent(string &);
  37    BOOL Persistent(const char *&);
  38    BOOL Persistent(void *, size_t);
  39    BOOL Persistent(const char *, size_t);
  40    BOOL Persistent(real &);
  41    BOOL Persistent(integer &);
  42    BOOL Persistent(vector &);
  43    BOOL Persistent(boolean &);
  44    BOOL Persistent(ulong &);
  45    BOOL Persistent(cMultiParm &);
  46
  47    virtual BOOL Persistence() { return FALSE; }
  48    virtual const char *GetName() { return "no factory"; }
  49
  50 protected:
  51    static tPersistIOFunc gm_pfnIO;
  52    static void *        gm_pContextIO;
  53    static BOOL          gm_fReading;
  54 };
  55
  56 ///////////////////////////////////////
  57
  58 inline BOOL sPersistent::ReadWrite(tPersistIOFunc pfnIO,
  59                                    void * pContextIO, BOOL fReading)
  60 {
  61    gm_pContextIO = pContextIO;
  62    gm_pfnIO      = pfnIO;
  63    gm_fReading   = fReading;
  64
  65    return Persistence();
  66 }
  67
  68 ///////////////////////////////////////
  69
  70 inline BOOL sPersistent::Persistent(void * p, size_t size)
  71 {
  72    return (*gm_pfnIO)(gm_pContextIO, p, size) == size;
  73 }
  74
  75 ///////////////////////////////////////
  76
  77 inline BOOL sPersistent::Persistent(const char * p, size_t size)
  78 {
  79    return Persistent((void *)p, size);
  80 }
  81
  82 ///////////////////////////////////////
  83
  84 inline BOOL sPersistent::Persistent(real & r)
  85 {
  86    return (*gm_pfnIO)(gm_pContextIO, &r, sizeof(real)) == sizeof(real);
  87 }
  88
  89 ///////////////////////////////////////
  90
  91 inline BOOL sPersistent::Persistent(integer & i)
  92 {
  93    return (*gm_pfnIO)(gm_pContextIO, &i, sizeof(integer)) == sizeof(integer);
  94 }
  95
  96 ///////////////////////////////////////
  97
  98 inline BOOL sPersistent::Persistent(vector & v)
  99 {
 100    return (*gm_pfnIO)(gm_pContextIO, &v, sizeof(vector)) == sizeof(vector);
 101 }
 102
 103 ///////////////////////////////////////
 104
 105 inline BOOL sPersistent::Persistent(boolean & b)
 106 {
 107    return (*gm_pfnIO)(gm_pContextIO, &b, sizeof(boolean)) == sizeof(boolean);
 108 }
 109
 110 ///////////////////////////////////////
 111
 112 inline BOOL sPersistent::Persistent(ulong & i)
 113 {
 114    return (*gm_pfnIO)(gm_pContextIO, &i, sizeof(ulong)) == sizeof(ulong);
 115 }
 116
 117
 118 ///////////////////////////////////////////////////////////////////////////////
 119
 120
 121 typedef sPersistent * (*tPersistFactory)();
 122
 123 struct sPersistReg;
 124 extern sPersistReg *g_pPersistFactoryList;
 125
 126 struct sPersistReg
 127 {
 128    sPersistReg(tPersistFactory pfnFactory, const char *pszName)
 129       : m_pfnFactory(pfnFactory),
 130         m_pszName(pszName)
 131    {
 132       m_pNext = g_pPersistFactoryList;
 133       g_pPersistFactoryList = this;
 134    }
 135
 136    const tPersistFactory m_pfnFactory;
 137    const char *m_pszName;
 138
 139    sPersistReg *m_pNext;
 140 };
 141
 142 extern sPersistent * PersistReadWrite(sPersistent *p, tPersistIOFunc pfnIO,
 143                                       void * pContextIO, BOOL fReading);
 144
 145 extern sPersistReg* PersistLookupReg(const char* pszName);
 146
 147 ///////////////////////////////////////////////////////////////////////////////
 148
 149
 150 #define PERSIST_DECLARE() \
 151    virtual const char * GetName()
 152
 153 #define PERSIST_DECLARE_PERSISTENT() \
 154    PERSIST_DECLARE(); \
 155    BOOL Persistence()
 156
 157 ///////////////////////////////////////
 158
 159 #define PERSIST_IMPLEMENT(STR) \
 160    \
 161    sPersistent * g_PersistFactory##STR () \
 162    { \
 163       sPersistent * p = new STR; \
 164       return p; \
 165    } \
 166    \
 167    sPersistReg g_PersistReg##STR(g_PersistFactory##STR, #STR); \
 168    \
 169    const char * STR::GetName() \
 170    { \
 171       return #STR; \
 172    }
 173
 174 #define PERSIST_IMPLEMENT_PERSISTENT(STR) \
 175    PERSIST_IMPLEMENT(STR); \
 176    BOOL STR::Persistence()
 177
 178 #define PersistentEnum(e) \
 179    Assert_(sizeof(e) == sizeof(int)); \
 180    Persistent(*((int *)(&(e))))
 181
 182 ///////////////////////////////////////////////////////////////////////////////
 183
 184 #endif // ~__PERSIST_H