00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00043 #ifndef CCXX_PERSIST_H_
00044 #define CCXX_PERSIST_H_
00045
00046 #ifndef CCXX_CONFIG_H_
00047 #include <cc++/config.h>
00048 #endif
00049
00050 #ifndef CCXX_EXCEPTIONS_H_
00051 #include <cc++/exception.h>
00052 #endif
00053
00054 #ifndef CCXX_MISSING_H_
00055 #include <cc++/missing.h>
00056 #endif
00057
00058 #ifndef CCXX_STRING_H_
00059 #include <cc++/string.h>
00060 #endif
00061
00062 #ifdef HAVE_ZLIB_H
00063 #ifndef NO_COMPRESSION
00064 #include <zlib.h>
00065 #endif
00066 #else
00067 #define NO_COMPRESSION
00068 #endif
00069
00070 #include <iostream>
00071 #include <string>
00072 #include <vector>
00073 #include <deque>
00074 #include <map>
00075
00076 #ifdef CCXX_NAMESPACES
00077 namespace ost {
00078 #define NS_PREFIX ost::
00079 #else
00080 #define NS_PREFIX
00081 #endif
00082
00083 #ifdef CCXX_EXCEPTIONS
00084 #ifdef COMMON_STD_EXCEPTION
00085
00086 class __EXPORT PersistException : public Exception
00087 {
00088 public:
00089 PersistException(const String &what) : Exception(what) {};
00090 };
00091
00092 #else
00093
00094 class __EXPORT PersistException
00095 {
00096 public:
00097 PersistException(const String& reason);
00098 inline const String& getString() const
00099 {return Exception::getString();};
00100
00101 virtual ~PersistException() {} throw();
00102 protected:
00103 String _what;
00104 };
00105
00106 #endif
00107 #endif
00108
00109
00110 typedef class BaseObject* (*NewBaseObjectFunction) (void);
00111
00120 class __EXPORT TypeManager
00121 {
00122 public:
00123
00128 class Registration
00129 {
00130 public:
00131 Registration(const char* name, NewBaseObjectFunction func);
00132 virtual ~Registration();
00133 private:
00134 String myName;
00135 };
00136
00140 static void add(const char* name, NewBaseObjectFunction construction);
00141
00145 static void remove(const char* name);
00146
00152 static BaseObject* createInstanceOf(const char* name);
00153
00154 typedef std::map<String,NewBaseObjectFunction> StringFunctionMap;
00155 };
00156
00157
00158
00159
00160
00161
00162
00163 #define DECLARE_PERSISTENCE(ClassType) \
00164 public: \
00165 friend NS_PREFIX Engine& operator>>( NS_PREFIX Engine& ar, ClassType *&ob); \
00166 friend NS_PREFIX Engine& operator<<( NS_PREFIX Engine& ar, ClassType const &ob); \
00167 friend NS_PREFIX BaseObject *createNew##ClassType(); \
00168 virtual const char* getPersistenceID() const; \
00169 static NS_PREFIX TypeManager::Registration registrationFor##ClassType;
00170
00171 #define IMPLEMENT_PERSISTENCE(ClassType, FullyQualifiedName) \
00172 NS_PREFIX BaseObject *createNew##ClassType() { return new ClassType; } \
00173 const char* ClassType::getPersistenceID() const {return FullyQualifiedName;} \
00174 NS_PREFIX Engine& operator>>(NS_PREFIX Engine& ar, ClassType &ob) \
00175 { ar >> (NS_PREFIX BaseObject &) ob; return ar; } \
00176 NS_PREFIX Engine& operator>>(NS_PREFIX Engine& ar, ClassType *&ob) \
00177 { ar >> (NS_PREFIX BaseObject *&) ob; return ar; } \
00178 NS_PREFIX Engine& operator<<(NS_PREFIX Engine& ar, ClassType const &ob) \
00179 { ar << (NS_PREFIX BaseObject const *)&ob; return ar; } \
00180 NS_PREFIX TypeManager::Registration \
00181 ClassType::registrationFor##ClassType(FullyQualifiedName, \
00182 createNew##ClassType);
00183
00184 class Engine;
00185
00205 class __EXPORT BaseObject
00206 {
00207 public:
00213 BaseObject();
00214
00218 virtual ~BaseObject();
00219
00223 virtual const char* getPersistenceID() const;
00224
00230 virtual bool write(Engine& archive) const;
00231
00237 virtual bool read(Engine& archive);
00238 };
00239
00240
00251 class __EXPORT Engine
00252 {
00253 public:
00257 enum EngineMode
00258 {
00259 modeRead,
00260 modeWrite
00261 };
00262
00268 Engine(std::iostream& stream, EngineMode mode) THROWS (PersistException);
00269
00274 void sync();
00275
00276 virtual ~Engine();
00277
00278
00279
00280
00284 void write(const BaseObject &object) THROWS (PersistException)
00285 { write(&object); };
00286
00290 void write(const BaseObject *object) THROWS (PersistException);
00291
00292
00293
00294 #define CCXX_ENGINEWRITE_REF(valref) writeBinary((const uint8*)&valref,sizeof(valref))
00295 void write(int8 i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00296 void write(uint8 i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00297 void write(int16 i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00298 void write(uint16 i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00299 void write(int32 i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00300 void write(uint32 i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00301 #ifdef HAVE_64_BITS
00302 void write(int64 i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00303 void write(uint64 i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00304 #endif
00305 void write(float i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00306 void write(double i) THROWS (PersistException) { CCXX_ENGINEWRITE_REF(i); }
00307 #undef CCXX_ENGINEWRITE_REF
00308
00309 void write(const String& str) THROWS (PersistException);
00310 void write(const std::string& str) THROWS (PersistException);
00311
00312
00313 void writeBinary(const uint8* data, const uint32 size) THROWS (PersistException);
00314
00315
00316
00317
00321 void read(BaseObject &object) THROWS (PersistException);
00322
00326 void read(BaseObject *&object) THROWS (PersistException);
00327
00328
00329
00330 #define CCXX_ENGINEREAD_REF(valref) readBinary((uint8*)&valref,sizeof(valref))
00331 void read(int8& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00332 void read(uint8& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00333 void read(int16& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00334 void read(uint16& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00335 void read(int32& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00336 void read(uint32& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00337 #ifdef HAVE_64_BITS
00338 void read(int64& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00339 void read(uint64& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00340 #endif
00341 void read(float& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00342 void read(double& i) THROWS (PersistException) { CCXX_ENGINEREAD_REF(i); }
00343 #undef CCXX_ENGINEREAD_REF
00344
00345 void read(String& str) THROWS (PersistException);
00346 void read(std::string& str) THROWS (PersistException);
00347
00348
00349 void readBinary(uint8* data, uint32 size) THROWS (PersistException);
00350
00351 private:
00356 void readObject(BaseObject* object) THROWS (PersistException);
00357
00361 const String readClass() THROWS (PersistException);
00362
00363
00367 std::iostream& myUnderlyingStream;
00368
00372 EngineMode myOperationalMode;
00373
00377 typedef std::vector<BaseObject*> ArchiveVector;
00378 typedef std::map<BaseObject const*, int32> ArchiveMap;
00379 typedef std::vector<String> ClassVector;
00380 typedef std::map<String, int32> ClassMap;
00381
00382 ArchiveVector myArchiveVector;
00383 ArchiveMap myArchiveMap;
00384 ClassVector myClassVector;
00385 ClassMap myClassMap;
00386
00387
00388 #ifndef NO_COMPRESSION
00389 z_stream myZStream;
00390 uint8* myCompressedDataBuffer;
00391 uint8* myUncompressedDataBuffer;
00392 uint8* myLastUncompressedDataRead;
00393 #endif
00394 };
00395
00396
00398 __EXPORT Engine& operator >>( Engine& ar, BaseObject &ob) THROWS (PersistException);
00400 __EXPORT Engine& operator >>( Engine& ar, BaseObject *&ob) THROWS (PersistException);
00402 __EXPORT Engine& operator <<( Engine& ar, BaseObject const &ob) THROWS (PersistException);
00404 __EXPORT Engine& operator <<( Engine& ar, BaseObject const *ob) THROWS (PersistException);
00405
00407 __EXPORT Engine& operator >>( Engine& ar, int8& ob) THROWS (PersistException);
00409 __EXPORT Engine& operator <<( Engine& ar, int8 ob) THROWS (PersistException);
00410
00412 __EXPORT Engine& operator >>( Engine& ar, uint8& ob) THROWS (PersistException);
00414 __EXPORT Engine& operator <<( Engine& ar, uint8 ob) THROWS (PersistException);
00415
00417 __EXPORT Engine& operator >>( Engine& ar, int16& ob) THROWS (PersistException);
00419 __EXPORT Engine& operator <<( Engine& ar, int16 ob) THROWS (PersistException);
00420
00422 __EXPORT Engine& operator >>( Engine& ar, uint16& ob) THROWS (PersistException);
00424 __EXPORT Engine& operator <<( Engine& ar, uint16 ob) THROWS (PersistException);
00425
00427 __EXPORT Engine& operator >>( Engine& ar, int32& ob) THROWS (PersistException);
00429 __EXPORT Engine& operator <<( Engine& ar, int32 ob) THROWS (PersistException);
00430
00432 __EXPORT Engine& operator >>( Engine& ar, uint32& ob) THROWS (PersistException);
00434 __EXPORT Engine& operator <<( Engine& ar, uint32 ob) THROWS (PersistException);
00435
00436 #ifdef HAVE_64_BITS
00437
00438 __EXPORT Engine& operator >>( Engine& ar, int64& ob) THROWS (PersistException);
00440 __EXPORT Engine& operator <<( Engine& ar, int64 ob) THROWS (PersistException);
00441
00443 __EXPORT Engine& operator >>( Engine& ar, uint64& ob) THROWS (PersistException);
00445 __EXPORT Engine& operator <<( Engine& ar, uint64 ob) THROWS (PersistException);
00446 #endif
00447
00449 __EXPORT Engine& operator >>( Engine& ar, float& ob) THROWS (PersistException);
00451 __EXPORT Engine& operator <<( Engine& ar, float ob) THROWS (PersistException);
00452
00454 __EXPORT Engine& operator >>( Engine& ar, double& ob) THROWS (PersistException);
00456 __EXPORT Engine& operator <<( Engine& ar, double ob) THROWS (PersistException);
00457
00459 __EXPORT Engine& operator >>( Engine& ar, String& ob) THROWS (PersistException);
00461 __EXPORT Engine& operator <<( Engine& ar, String ob) THROWS (PersistException);
00462
00464 __EXPORT Engine& operator >>( Engine& ar, std::string& ob) THROWS (PersistException);
00466 __EXPORT Engine& operator <<( Engine& ar, std::string ob) THROWS (PersistException);
00467
00469 __EXPORT Engine& operator >>( Engine& ar, bool& ob) THROWS (PersistException);
00471 __EXPORT Engine& operator <<( Engine& ar, bool ob) THROWS (PersistException);
00472
00482 template<class T>
00483 Engine& operator <<( Engine& ar, typename std::vector<T> const& ob) THROWS (PersistException)
00484 {
00485 ar << (uint32)ob.size();
00486 for(unsigned int i=0; i < ob.size(); ++i)
00487 ar << ob[i];
00488 return ar;
00489 }
00490
00496 template<class T>
00497 Engine& operator >>( Engine& ar, typename std::vector<T>& ob) THROWS (PersistException)
00498 {
00499 ob.clear();
00500 uint32 siz;
00501 ar >> siz;
00502 ob.resize(siz);
00503 for(uint32 i=0; i < siz; ++i)
00504 ar >> ob[i];
00505 return ar;
00506 }
00507
00513 template<class T>
00514 Engine& operator <<( Engine& ar, typename std::deque<T> const& ob) THROWS (PersistException)
00515 {
00516 ar << (uint32)ob.size();
00517 for(typename std::deque<T>::const_iterator it=ob.begin(); it != ob.end(); ++it)
00518 ar << *it;
00519 return ar;
00520 }
00521
00527 template<class T>
00528 Engine& operator >>( Engine& ar, typename std::deque<T>& ob) THROWS (PersistException)
00529 {
00530 ob.clear();
00531 uint32 siz;
00532 ar >> siz;
00533
00534 for(uint32 i=0; i < siz; ++i)
00535 {
00536 T node;
00537 ar >> node;
00538 ob.push_back(node);
00539
00540 }
00541 return ar;
00542 }
00543
00549 template<class Key, class Value>
00550 Engine& operator <<( Engine& ar, typename std::map<Key,Value> const & ob) THROWS (PersistException)
00551 {
00552 ar << (uint32)ob.size();
00553 for(typename std::map<Key,Value>::const_iterator it = ob.begin();it != ob.end();++it)
00554 ar << it->first << it->second;
00555 return ar;
00556 }
00557
00563 template<class Key, class Value>
00564 Engine& operator >>( Engine& ar, typename std::map<Key,Value>& ob) THROWS (PersistException)
00565 {
00566 ob.clear();
00567 uint32 siz;
00568 ar >> siz;
00569 for(uint32 i=0; i < siz; ++i) {
00570 Key a;
00571 ar >> a;
00572 ar >> ob[a];
00573 }
00574 return ar;
00575 }
00576
00581 template<class x, class y>
00582 Engine& operator <<( Engine& ar, std::pair<x,y> &ob) THROWS (PersistException)
00583 {
00584 ar << ob.first << ob.second;
00585 return ar;
00586 }
00587
00592 template<class x, class y>
00593 Engine& operator >>(Engine& ar, std::pair<x, y> &ob) THROWS (PersistException)
00594 {
00595 ar >> ob.first >> ob.second;
00596 return ar;
00597 }
00598
00599 #ifdef CCXX_NAMESPACES
00600 }
00601 #endif
00602
00603 #endif
00604