source: Sophya/trunk/SophyaLib/BaseTools/ppersist.h@ 1192

Last change on this file since 1192 was 895, checked in by ansari, 25 years ago

Documentation de fichiers - Reza 12/4/2000
File size: 14.6 KB
Line 
1// This may look like C code, but it is really -*- C++ -*-
2
3#ifndef PPERSIST_H_SEEN
4#define PPERSIST_H_SEEN
5
6// Flat file persistance, similar to Java serialization
7//
8// E. Aubourg CEA DAPNIA/SPP 1999
9// R. Ansari LAL IN2P3/CNRS 03/2000
10
11
12#include "machdefs.h"
13#include "pexceptions.h"
14#include "gnumd5.h"
15
16
17#include <time.h>
18
19#include <string>
20#include <map>
21#include <vector>
22#include <typeinfo>
23
24
25// Classe de base pour les objets qui peuvent devenir PPersist
26
27namespace SOPHYA {
28
29 class AnyDataObj;
30
31 class PIOPersist;
32 class PInPersist;
33 class POutPersist;
34 class PPersist;
35
36//! Persistent (delegate or mixin) base class
37 class PPersist {
38 public:
39 virtual ~PPersist() {}
40// J'ajoute cette fonction pour assurer la compatibilite
41// avec l'ancien PPersist d'Eros (Reza 23/04/99)
42 virtual int_4 ClassId() const { return(0); }
43
44 void Write(string const& fn) const;
45 void Read(string const& fn);
46
47 virtual void Write(POutPersist&) const;
48 void Read(PInPersist& s); // Reads the type tag and the object
49 void Write(POutPersist&, string const& tag) const;
50 void ReadAtTag(PInPersist& s, string const& tag);
51
52 virtual AnyDataObj* DataObj()=0; // Retourne l'objet reel
53 virtual void SetDataObj(AnyDataObj &)=0;
54
55 virtual uint_8 getMemOId() const ; // Renvoie l'identificateur de l'objet - par defaut=0
56 // Ces deux methodes doivent etre redefinies si getMemOId() renvoie non nul (>0)
57 virtual void ShareDataReference(PPersist &);
58 virtual PPersist* CloneSharedReference();
59 // doit etre surcharge pour renvoyer un mem-oid correct
60 protected:
61 virtual void ReadSelf(PInPersist&)=0;
62 virtual void WriteSelf(POutPersist&) const=0;
63
64 friend class PInPersist;
65 friend class POutPersist;
66 };
67
68
69
70//! Ancestor for PInPersist and POutPersist PPF streams.
71// Handles (statically) the registration of classes.
72
73 class PIOPersist {
74 public:
75 enum {PPS_NATIVE = -1, PPS_LITTLE_ENDIAN = 0, PPS_BIG_ENDIAN = 1};
76 typedef PPersist* (*ClassCreatorFunc)();
77
78 static void RegisterPPHandlerClass(uint_8 classId, string ppclass_name, ClassCreatorFunc f);
79 static void RegisterDataObjClass(uint_8 classId, string class_name);
80
81 static ClassCreatorFunc FindCreatorFunc(uint_8 classId);
82
83 static string getPPClassName(uint_8 classId);
84 static uint_8 getPPClassId(string const & typ_name);
85 static uint_8 getPPClassId(PPersist const & ppo);
86 static string getDataObjClassName(uint_8 classId);
87 static uint_8 getDataObjClassId(string const & typ_name);
88 static uint_8 getDataObjClassId(AnyDataObj const & o);
89
90 static uint_8 Hash(string const& typname) {
91 md5_init(&ctx);
92 md5_write(&ctx, (unsigned char*) typname.c_str(), typname.size());
93 md5_final(&ctx);
94 return ( *((uint_8*) ctx.buf) + *((uint_8*) (ctx.buf+8)));
95 }
96 static MD5_CONTEXT ctx;
97
98 static void Initialize(); // Pour initialiser classList
99
100 string FileName() { return filename; } // Retourne le nom de fichier
101
102 private:
103
104 typedef map<uint_8, ClassCreatorFunc, less<uint_8> > ClassList;
105 // Pas de createur appele pour objets statiques sur Linux - $CHECK$ Reza 26/04/99
106 static ClassList * ppclassList; // PPersist class list
107 static map<string, uint_8> * ppclassNameList; // PPersist classId = f(PPersistClassName)
108 static map<string, uint_8> * dobjclassNameList; // PPersist classId = f(DataObjClassName)
109
110 protected:
111
112 enum {PPS_NULL = 0, // this is a null object
113 PPS_STRING = 1, // string, length (4b) + data
114 PPS_OBJECT = 2, // classId, data...
115 PPS_REFERENCE = 3, // objectId
116 PPS_TAG = 4, // tag entries
117 PPS_EOF = 5, // Just before tag infomation, offset to PPS_TAG
118 PPS_ENDOBJECT = 6, // marks the end of a given object information
119 PPS_TAG_MARK = 7, // To have a name tag, position marker in a file
120 PPS_SIMPLE = 16, // 16 + number of bytes, up to 8 bytes
121 PPS_SIMPLE_ARRAY4 = 32, // 32 + number of bytes, up to 8 bytes, then 4 bytes of length
122 PPS_SIMPLE_ARRAY8 = 48 // 48 + number of bytes, up to 8 bytes, then 8 bytes of length
123 };
124 // The following values are used with PPS_SIMPLE and PPS_SIMPLE_ARRAY (Using OR)
125 enum {PPS_DATATYPE_CHAR = 0, // 0 : DataType=character
126 PPS_DATATYPE_FLOAT = 64, // 64 : DataType=float
127 PPS_DATATYPE_INTEGER = 128, // 128 :DataType=integer
128 PPS_DATATYPE_UNSIGNED = 192 // 192 :DataType=Unsigned integer
129 };
130
131 map<string, int_8> tags;
132 string filename;
133 };
134
135
136 // TBD : use hash tables instead of maps. Check hashtbl status in STL.
137
138//! Input stream for PPersit objects.
139 class PInPersist : public PIOPersist {
140 public:
141 PInPersist(string const& flnm, bool scan=true);
142 ~PInPersist();
143
144 bool GotoTag(string const& name);
145 int NbTags();
146 bool GotoTagNum(int itag); // 0..NbTags-1
147 string GetTagName(int itag); // 0..NbTags-1
148 string GetTagClassName(int itag); // 0..NbTags-1
149 vector<string> const & GetTagNames();
150
151 void GetByte (char& c);
152 void GetBytes(void* ptr, size_t bytes);
153 void GetR4 (r_4&);
154 void GetR4s (r_4*, size_t);
155 void GetR8 (r_8&);
156 void GetR8s (r_8*, size_t);
157 void GetI2 (int_2&);
158 void GetI2s (int_2*, size_t);
159 void GetU2 (uint_2&);
160 void GetU2s (uint_2*, size_t);
161 void GetI4 (int_4&);
162 void GetI4s (int_4*, size_t);
163 void GetU4 (uint_4&);
164 void GetU4s (uint_4*, size_t);
165 void GetI8 (int_8&);
166 void GetI8s (int_8*, size_t);
167 void GetU8 (uint_8&);
168 void GetU8s (uint_8*, size_t);
169 void GetLine (char* ptr, size_t len);
170 void GetStr (string&);
171
172 void Get(char& c) {GetByte(c);}
173 void Get(r_4& x) {GetR4(x);}
174 void Get(r_8& x) {GetR8(x);}
175 void Get(uint_2& x) {GetU2(x);}
176 void Get(int_2& x) {GetI2(x);}
177 void Get(uint_4& x) {GetU4(x);}
178 void Get(int_4& x) {GetI4(x);}
179 void Get(uint_8& x) {GetU8(x);}
180 void Get(int_8& x) {GetI8(x);}
181 void Get(r_4* x, size_t n) {GetR4s(x,n);}
182 void Get(r_8* x, size_t n) {GetR8s(x,n);}
183 void Get(uint_2* x, size_t n) {GetU2s(x,n);}
184 void Get(int_2* x, size_t n) {GetI2s(x,n);}
185 void Get(uint_4* x, size_t n) {GetU4s(x,n);}
186 void Get(int_4* x, size_t n) {GetI4s(x,n);}
187 void Get(uint_8* x, size_t n) {GetU8s(x,n);}
188 void Get(int_8* x, size_t n) {GetI8s(x,n);}
189 void Get(string& x) {GetStr(x);}
190
191 // Object Reading
192 PPersist* ReadObject();
193 void GetObject(AnyDataObj & o);
194 void GetObject(AnyDataObj & o, string tagname);
195 PPersist* GetPPObject(AnyDataObj * po=NULL);
196
197 int Version() {return version;}
198 time_t CreationDate() { return creationdate; }
199 string CreationDateStr();
200
201 void AnalyseTags(int lev=0); // List (all or some) tags ...
202
203 // Reza 03/2000
204 // Methodes qui pourraient etre protected, mais doivent etre utilisables par PPersist
205 void ReadReference(PPersist & ppo); // Fill the ppo object from the reference tag
206 PPersist * ReadReference(); // Creates object from the reference tag
207 void KeepOId(uint_8 oid, PPersist & ppo); // Keeps the ppo in the objList
208
209 protected:
210 void CheckTag (short datasz, short datatype);
211 void CheckArrayTag(short datasz, size_t sz, short datatype);
212 void GetTypeTag (unsigned char& c);
213 void GetRawByte (char& c);
214 void GetRawUByte (unsigned char& c);
215 void GetRawBytes(void* ptr, size_t bytes);
216 void GetRawI2 (int_2&);
217 void GetRawI4 (int_4&);
218 void GetRawI8 (int_8&);
219 void GetRawU8 (uint_8&);
220
221 void Scan();
222
223 istream* s;
224
225 bool bigEndian;
226 int version;
227
228 time_t creationdate;
229
230 // already read objects
231 typedef map<uint_8, PPersist * > ObjList;
232 ObjList objList;
233 // Si on a fait une lecture non sequentielle -> seqread = false
234 bool seqread;
235 friend class PPersist;
236 };
237
238//! Output stream for PPersit objects.
239 class POutPersist : public PIOPersist {
240 public:
241 POutPersist(string const& flnm, int endianness = PPS_NATIVE);
242 ~POutPersist();
243
244 void WriteTag(string const& name);
245
246 void PutByte (char c);
247 void PutBytes(void const* ptr, size_t bytes);
248 void PutR4 (r_4);
249 void PutR4s (r_4 const*, size_t);
250 void PutR8 (r_8);
251 void PutR8s (r_8 const*, size_t);
252 void PutI2 (int_2);
253 void PutI2s (int_2 const*, size_t);
254 void PutU2 (uint_2);
255 void PutU2s (uint_2 const*, size_t);
256 void PutI4 (int_4);
257 void PutI4s (int_4 const*, size_t);
258 void PutU4 (uint_4);
259 void PutU4s (uint_4 const*, size_t);
260 void PutI8 (int_8);
261 void PutI8s (int_8 const*, size_t);
262 void PutU8 (uint_8);
263 void PutU8s (uint_8 const*, size_t);
264 void PutLine (char const* ptr, size_t len=0); // deprecated ?
265 void PutStr (string const&);
266 void PutPPObject (PPersist const*); // Like doing Write(stream) on PPersist object
267
268 void PutObject(AnyDataObj & o); // Creates the corresponding PPersist Object and call Write()
269 void PutObject(AnyDataObj & o, string tagname);
270
271 void Put(char c) {PutByte(c);}
272 void Put(r_4 x) {PutR4(x);}
273 void Put(r_8 x) {PutR8(x);}
274 void Put(uint_2 x) {PutU2(x);}
275 void Put(int_2 x) {PutI2(x);}
276 void Put(uint_4 x) {PutU4(x);}
277 void Put(int_4 x) {PutI4(x);}
278 void Put(uint_8 x) {PutU8(x);}
279 void Put(int_8 x) {PutI8(x);}
280 void Put(r_4 const* x, size_t n) {PutR4s(x,n);}
281 void Put(r_8 const* x, size_t n) {PutR8s(x,n);}
282 void Put(uint_2 const* x, size_t n) {PutU2s(x,n);}
283 void Put(int_2 const* x, size_t n) {PutI2s(x,n);}
284 void Put(uint_4 const* x, size_t n) {PutU4s(x,n);}
285 void Put(int_4 const* x, size_t n) {PutI4s(x,n);}
286 void Put(uint_8 const* x, size_t n) {PutU8s(x,n);}
287 void Put(int_8 const* x, size_t n) {PutI8s(x,n);}
288 void Put(string const& s) {PutStr(s);}
289 void Put(PPersist const* x) {PutPPObject(x);}
290
291
292 protected:
293 ostream* s;
294 bool bigEndian;
295
296 void PutArrayTag(short datasz, size_t sz, short datatype);
297 void PutRawByte (char);
298 void PutRawUByte (unsigned char);
299 void PutRawI2 (int_2);
300 void PutRawI4 (int_4);
301 void PutRawI8 (int_8);
302 void PutRawU8 (uint_8);
303 void PutRawBytes(void const* ptr, size_t bytes);
304 bool serializeNullAndRepeat(PPersist const* x);
305 uint_8 findObjectId(PPersist const* x, int_8 & pos);
306 uint_8 assignObjectId(PPersist const* x);
307
308 // objreftag contains the assigned POutStream Object Id and the stream position
309 // of the original written object
310 typedef struct { uint_8 ppsoid; int_8 ppspos; } objreftag;
311 // already serialized objects are kept in a map as a function of the Objects memory Id
312 typedef map<uint_8, objreftag, less<uint_8> > ObjList;
313 ObjList objList;
314 uint_8 pps_OId; // PPS Object Id
315 };
316
317
318#define RAWPERSISTIO(_Type_,_xtyp_) \
319 inline POutPersist& operator << (POutPersist& c, _Type_ const& data) \
320 { \
321 c.Put##_xtyp_(data); \
322 return c; \
323 } \
324 \
325 inline PInPersist& operator >> (PInPersist& c, _Type_& data) \
326 { \
327 c.Get##_xtyp_(data); \
328 return c; \
329 }
330
331 RAWPERSISTIO(int_4,I4);
332 RAWPERSISTIO(uint_4,U4);
333 RAWPERSISTIO(int_2,I2);
334 RAWPERSISTIO(uint_2,U2);
335 RAWPERSISTIO(char,Byte);
336 RAWPERSISTIO(r_4,R4);
337 RAWPERSISTIO(r_8,R8);
338
339#if 0
340#define STRUCTPERSISTIO(_Type_, _field_, _size_) \
341 inline POutPersist& operator << (POutPersist& c, _Type_ const& data) \
342 { \
343 c.PutBytes(&data._field_, _size_); \
344 return c; \
345 } \
346 \
347 inline PInPersist& operator >> (PInPersist& c, _Type_& data) \
348 { \
349 c.GetBytes(&data._field_, _size_); \
350 return c; \
351 }
352
353#endif
354
355
356// --- Cela risque d'etre dangereux --- On le laisse au niveau des DataObj
357// Reza 24/3/2000
358// inline POutPersist& operator << (POutPersist& c, PPersist const& obj)
359// {
360// obj.Write(c);
361// return c;
362// }
363
364// inline PInPersist& operator >> (PInPersist& c, PPersist& obj)
365// {
366// obj.Read(c);
367// return c;
368// }
369
370 // Utility class to
371 // - compute the class ID from a MD5 hash of the class name
372 // - register classes with PIOPersist, through PPRegister macro
373
374//! template class for handling the PPersist registration mechanism.
375 template <class T>
376 class PPersistRegistrar {
377 public:
378 static PPersist* Create() {return new T();}
379 static void Register(string id) { PIOPersist::RegisterPPHandlerClass(Hash(id), typeid(T).name(), Create); }
380 static uint_8 Hash(string id) {
381 return PIOPersist::Hash(id);
382 }
383 };
384
385#define PPRegister(className) PPersistRegistrar<className>::Register(#className);
386#define DObjRegister(ppclassName, className) PIOPersist::RegisterDataObjClass(PIOPersist::Hash(#ppclassName), typeid(className).name());
387
388} // namespace
389
390#endif
Note: See TracBrowser for help on using the repository browser.