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
00252 class __EXPORT Engine
00253 {
00254 public:
00259 #ifdef CCXX_EXCEPTIONS
00260 class Exception : public PersistException
00261 {
00262 public:
00263 Exception(const String &reason);
00264 };
00265 #endif
00266
00270 enum EngineMode
00271 {
00272 modeRead,
00273 modeWrite
00274 };
00275
00281 Engine(std::iostream& stream, EngineMode mode) THROWS (PersistException);
00282
00287 void sync();
00288
00289 virtual ~Engine();
00290
00291
00292
00293
00297 void write(const BaseObject &object) THROWS (Exception)
00298 { write(&object); };
00299
00303 void write(const BaseObject *object) THROWS (Exception);
00304
00305
00306
00307 #define CCXX_ENGINEWRITE_REF(valref) writeBinary((const uint8*)&valref,sizeof(valref))
00308 void write(int8 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00309 void write(uint8 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00310 void write(int16 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00311 void write(uint16 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00312 void write(int32 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00313 void write(uint32 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00314 #ifdef HAVE_64_BITS
00315 void write(int64 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00316 void write(uint64 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00317 #endif
00318 void write(float i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00319 void write(double i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
00320 #undef CCXX_ENGINEWRITE_REF
00321
00322 void write(const String& str) THROWS (Exception);
00323 void write(const std::string& str) THROWS (Exception);
00324
00325
00326 void writeBinary(const uint8* data, const uint32 size) THROWS (Exception);
00327
00328
00329
00330
00334 void read(BaseObject &object) THROWS (Exception);
00335
00339 void read(BaseObject *&object) THROWS (Exception);
00340
00341
00342
00343 #define CCXX_ENGINEREAD_REF(valref) readBinary((uint8*)&valref,sizeof(valref))
00344 void read(int8& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00345 void read(uint8& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00346 void read(int16& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00347 void read(uint16& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00348 void read(int32& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00349 void read(uint32& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00350 #ifdef HAVE_64_BITS
00351 void read(int64& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00352 void read(uint64& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00353 #endif
00354 void read(float& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00355 void read(double& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
00356 #undef CCXX_ENGINEREAD_REF
00357
00358 void read(String& str) THROWS (Exception);
00359 void read(std::string& str) THROWS (Exception);
00360
00361
00362 void readBinary(uint8* data, uint32 size) THROWS (Exception);
00363
00364 private:
00369 void readObject(BaseObject* object);
00370
00374 const String readClass();
00375
00376
00380 std::iostream& myUnderlyingStream;
00381
00385 EngineMode myOperationalMode;
00386
00390 typedef std::vector<BaseObject*> ArchiveVector;
00391 typedef std::map<BaseObject const*, int32> ArchiveMap;
00392 typedef std::vector<String> ClassVector;
00393 typedef std::map<String, int32> ClassMap;
00394
00395 ArchiveVector myArchiveVector;
00396 ArchiveMap myArchiveMap;
00397 ClassVector myClassVector;
00398 ClassMap myClassMap;
00399
00400
00401 #ifndef NO_COMPRESSION
00402 z_stream myZStream;
00403 uint8* myCompressedDataBuffer;
00404 uint8* myUncompressedDataBuffer;
00405 uint8* myLastUncompressedDataRead;
00406 #endif
00407 };
00408
00409
00411 __EXPORT Engine& operator >>( Engine& ar, BaseObject &ob) THROWS (Engine::Exception);
00413 __EXPORT Engine& operator >>( Engine& ar, BaseObject *&ob) THROWS (Engine::Exception);
00415 __EXPORT Engine& operator <<( Engine& ar, BaseObject const &ob) THROWS (Engine::Exception);
00417 __EXPORT Engine& operator <<( Engine& ar, BaseObject const *ob) THROWS (Engine::Exception);
00418
00420 __EXPORT Engine& operator >>( Engine& ar, int8& ob) THROWS (Engine::Exception);
00422 __EXPORT Engine& operator <<( Engine& ar, int8 ob) THROWS (Engine::Exception);
00423
00425 __EXPORT Engine& operator >>( Engine& ar, uint8& ob) THROWS (Engine::Exception);
00427 __EXPORT Engine& operator <<( Engine& ar, uint8 ob) THROWS (Engine::Exception);
00428
00430 __EXPORT Engine& operator >>( Engine& ar, int16& ob) THROWS (Engine::Exception);
00432 __EXPORT Engine& operator <<( Engine& ar, int16 ob) THROWS (Engine::Exception);
00433
00435 __EXPORT Engine& operator >>( Engine& ar, uint16& ob) THROWS (Engine::Exception);
00437 __EXPORT Engine& operator <<( Engine& ar, uint16 ob) THROWS (Engine::Exception);
00438
00440 __EXPORT Engine& operator >>( Engine& ar, int32& ob) THROWS (Engine::Exception);
00442 __EXPORT Engine& operator <<( Engine& ar, int32 ob) THROWS (Engine::Exception);
00443
00445 __EXPORT Engine& operator >>( Engine& ar, uint32& ob) THROWS (Engine::Exception);
00447 __EXPORT Engine& operator <<( Engine& ar, uint32 ob) THROWS (Engine::Exception);
00448
00449 #ifdef HAVE_64_BITS
00450
00451 __EXPORT Engine& operator >>( Engine& ar, int64& ob) THROWS (Engine::Exception);
00453 __EXPORT Engine& operator <<( Engine& ar, int64 ob) THROWS (Engine::Exception);
00454
00456 __EXPORT Engine& operator >>( Engine& ar, uint64& ob) THROWS (Engine::Exception);
00458 __EXPORT Engine& operator <<( Engine& ar, uint64 ob) THROWS (Engine::Exception);
00459 #endif
00460
00462 __EXPORT Engine& operator >>( Engine& ar, float& ob) THROWS (Engine::Exception);
00464 __EXPORT Engine& operator <<( Engine& ar, float ob) THROWS (Engine::Exception);
00465
00467 __EXPORT Engine& operator >>( Engine& ar, double& ob) THROWS (Engine::Exception);
00469 __EXPORT Engine& operator <<( Engine& ar, double ob) THROWS (Engine::Exception);
00470
00472 __EXPORT Engine& operator >>( Engine& ar, String& ob) THROWS (Engine::Exception);
00474 __EXPORT Engine& operator <<( Engine& ar, String ob) THROWS (Engine::Exception);
00475
00477 __EXPORT Engine& operator >>( Engine& ar, std::string& ob) THROWS (Engine::Exception);
00479 __EXPORT Engine& operator <<( Engine& ar, std::string ob) THROWS (Engine::Exception);
00480
00482 __EXPORT Engine& operator >>( Engine& ar, bool& ob) THROWS (Engine::Exception);
00484 __EXPORT Engine& operator <<( Engine& ar, bool ob) THROWS (Engine::Exception);
00485
00495 template<class T>
00496 Engine& operator <<( Engine& ar, typename std::vector<T> const& ob) THROWS (Engine::Exception)
00497 {
00498 ar << (uint32)ob.size();
00499 for(unsigned int i=0; i < ob.size(); ++i)
00500 ar << ob[i];
00501 return ar;
00502 }
00503
00509 template<class T>
00510 Engine& operator >>( Engine& ar, typename std::vector<T>& ob) THROWS (Engine::Exception)
00511 {
00512 ob.clear();
00513 uint32 siz;
00514 ar >> siz;
00515 ob.resize(siz);
00516 for(uint32 i=0; i < siz; ++i)
00517 ar >> ob[i];
00518 return ar;
00519 }
00520
00526 template<class T>
00527 Engine& operator <<( Engine& ar, typename std::deque<T> const& ob) THROWS (Engine::Exception)
00528 {
00529 ar << (uint32)ob.size();
00530 for(typename std::deque<T>::const_iterator it=ob.begin(); it != ob.end(); ++it)
00531 ar << *it;
00532 return ar;
00533 }
00534
00540 template<class T>
00541 Engine& operator >>( Engine& ar, typename std::deque<T>& ob) THROWS (Engine::Exception)
00542 {
00543 ob.clear();
00544 uint32 siz;
00545 ar >> siz;
00546
00547 for(uint32 i=0; i < siz; ++i)
00548 {
00549 T node;
00550 ar >> node;
00551 ob.push_back(node);
00552
00553 }
00554 return ar;
00555 }
00556
00562 template<class Key, class Value>
00563 Engine& operator <<( Engine& ar, typename std::map<Key,Value> const & ob) THROWS (Engine::Exception)
00564 {
00565 ar << (uint32)ob.size();
00566 for(typename std::map<Key,Value>::const_iterator it = ob.begin();it != ob.end();++it)
00567 ar << it->first << it->second;
00568 return ar;
00569 }
00570
00576 template<class Key, class Value>
00577 Engine& operator >>( Engine& ar, typename std::map<Key,Value>& ob) THROWS (Engine::Exception)
00578 {
00579 ob.clear();
00580 uint32 siz;
00581 ar >> siz;
00582 for(uint32 i=0; i < siz; ++i) {
00583 Key a;
00584 ar >> a;
00585 ar >> ob[a];
00586 }
00587 return ar;
00588 }
00589
00594 template<class x, class y>
00595 Engine& operator <<( Engine& ar, std::pair<x,y> &ob) THROWS (Engine::Exception)
00596 {
00597 ar << ob.first << ob.second;
00598 return ar;
00599 }
00600
00605 template<class x, class y>
00606 Engine& operator >>(Engine& ar, std::pair<x, y> &ob) THROWS (Engine::Exception)
00607 {
00608 ar >> ob.first >> ob.second;
00609 return ar;
00610 }
00611
00612 #ifdef CCXX_NAMESPACES
00613 }
00614 #endif
00615
00616 #endif
00617