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

Last change on this file was 4051, checked in by ansari, 14 years ago

modifs ds PPersist (classe PIOPersist) pour permettre l'enregistrement automatique (1ere lecture ou ecriture) de PPFWrapperSTLVector<T> (gestionnaire ppersist de std::vector<T> , Reza+cmv 25/02/2012
File size: 9.8 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// -------------------- Historique -----------------------
12// Separe en deux (CVS version 1.19 - ppersist.h)
13// Classes PPFBinaryIn/OutputStream ds ppfbinstream.h
14// -------------------------------------------------------
15
16
17#include "machdefs.h"
18#include "pexceptions.h"
19#include "gnumd5.h"
20#include "ppfbinstream.h"
21
22#include <string>
23#include <map>
24#include <vector>
25#include <typeinfo>
26
27
28// Classe de base pour les objets qui peuvent devenir PPersist
29
30namespace SOPHYA {
31
32 class AnyDataObj;
33
34 class PIOPersist;
35 class PInPersist;
36 class POutPersist;
37 class PPersist;
38
39//! Persistent (delegate or mixin) base class
40 class PPersist {
41 public:
42 virtual ~PPersist() {}
43
44 void Write(string const& fn) const;
45 void Read(string const& fn);
46
47 virtual void Write(POutPersist&) const;
48 virtual 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// Handles (statically) the registration of classes.
71
72 class PIOPersist {
73 public:
74 typedef PPersist* (*ClassCreatorFunc)();
75
76 static void RegisterPPHandlerClass(uint_8 classId, string ppclass_name, ClassCreatorFunc f);
77 static void RegisterDataObjClass(uint_8 classId, string class_name);
78
79 static void ListPPHandlers();
80 static void ListDataObjClasses();
81
82 static ClassCreatorFunc FindCreatorFunc(uint_8 classId);
83
84 static string getPPClassName(uint_8 classId);
85 static uint_8 getPPClassId(string const & typ_name);
86 static uint_8 getPPClassId(PPersist const & ppo);
87 static bool checkPPClassId(PPersist const & ppo);
88
89 static string getDataObjClassName(uint_8 classId);
90 static uint_8 getDataObjClassId(string const & typ_name);
91 static uint_8 getDataObjClassId(AnyDataObj const & o);
92
93 static uint_8 Hash(string const& typname);
94 static MD5_CONTEXT ctx;
95
96 static void Initialize(); // Pour initialiser classList
97
98
99 private:
100
101 typedef map<uint_8, ClassCreatorFunc, less<uint_8> > ClassList;
102 // Pas de createur appele pour objets statiques sur Linux - $CHECK$ Reza 26/04/99
103 static ClassList * ppclassList; // PPersist class list
104 static map<string, uint_8> * ppclassNameList; // PPersist classId = f(PPersistClassName)
105 static map<string, uint_8> * dobjclassNameList; // PPersist classId = f(DataObjClassName)
106
107 };
108
109
110// TBD : use hash tables instead of maps. Check hashtbl status in STL.
111
112//! Input stream for PPersit objects.
113 class PInPersist : public PPFBinaryInputStream, public PIOPersist {
114 public:
115 PInPersist(RawInOutStream * is, bool ad, bool scan=false);
116 PInPersist(string const& flnm, bool scan=true);
117 virtual ~PInPersist();
118
119 // A faire - Reza Dec 2003
120 string GetTagClassName(int itag);
121 // Object Reading
122 PPersist* ReadObject();
123 void GetObject(AnyDataObj & o);
124 void GetObject(AnyDataObj & o, string tagname);
125 PPersist* GetPPObject(AnyDataObj * po=NULL);
126
127 // Reza 03/2000
128 // Methodes qui pourraient etre protected, mais doivent etre utilisables par PPersist
129 void ReadReference(PPersist & ppo); // Fill the ppo object from the reference tag
130 PPersist * ReadReference(); // Creates object from the reference tag
131 void KeepOId(uint_8 oid, PPersist & ppo); // Keeps the ppo in the objList
132
133 protected:
134
135 // already read objects
136 typedef map<uint_8, PPersist * > ObjList;
137 ObjList objList;
138 friend class PPersist;
139 };
140
141//! Output stream for PPersit objects.
142 class POutPersist : public PPFBinaryOutputStream, public PIOPersist {
143 public:
144 POutPersist(RawInOutStream* os, bool ad, int endianness = PPS_NATIVE);
145 POutPersist(string const& flnm, int endianness = PPS_NATIVE);
146 virtual ~POutPersist();
147
148 // void Put(PPersist const* x) {PutPPObject(x);}
149
150 // Objet Write - Ecriture des objets
151 void PutPPObject (PPersist const*); // Like doing Write(stream) on PPersist object
152
153 void PutObject(AnyDataObj & o); // Creates the corresponding PPersist Object and call Write()
154 void PutObject(AnyDataObj & o, string tagname);
155
156
157 protected:
158 bool serializeNullAndRepeat(PPersist const* x);
159 uint_8 findObjectId(PPersist const* x, int_8 & pos);
160 uint_8 assignObjectId(PPersist const* x);
161
162 // objreftag contains the assigned POutStream Object Id and the stream position
163 // of the original written object
164 typedef struct { uint_8 ppsoid; int_8 ppspos; } objreftag;
165 // already serialized objects are kept in a map as a function of the Objects memory Id
166 typedef map<uint_8, objreftag, less<uint_8> > ObjList;
167 ObjList objList;
168 uint_8 pps_OId; // PPS Object Id
169 int wobj_level; // Niveau d'imbrication lors de l'ecriture d'objet
170 };
171
172//! \cond
173// Le macro suivant permettent de simplifier la declaration
174// des operateurs >> << sur les POutPersist et PInPersist
175#define RAWPERSISTIO(_Type_,_xtyp_) \
176 inline POutPersist& operator << (POutPersist& c, _Type_ const& data) \
177 { \
178 c.Put##_xtyp_(data); \
179 return c; \
180 } \
181 \
182 inline PInPersist& operator >> (PInPersist& c, _Type_& data) \
183 { \
184 c.Get##_xtyp_(data); \
185 return c; \
186 }
187
188// On utilise le macro RAWPERSISTIO pour declarer POutPersist << et PInPersist >>
189// pour les types de base r_4 r_8 int_4 int_8 ...
190 RAWPERSISTIO(int_8,I8);
191 RAWPERSISTIO(uint_8,U8);
192 RAWPERSISTIO(int_4,I4);
193 RAWPERSISTIO(uint_4,U4);
194 RAWPERSISTIO(int_2,I2);
195 RAWPERSISTIO(uint_2,U2);
196 RAWPERSISTIO(char,Byte);
197 RAWPERSISTIO(r_4,R4);
198 RAWPERSISTIO(r_8,R8);
199 RAWPERSISTIO(complex<r_4>,Z4);
200 RAWPERSISTIO(complex<r_8>,Z8);
201 RAWPERSISTIO(string,Str);
202
203#if 0
204#define STRUCTPERSISTIO(_Type_, _field_, _size_) \
205 inline POutPersist& operator << (POutPersist& c, _Type_ const& data) \
206 { \
207 c.PutBytes(&data._field_, _size_); \
208 return c; \
209 } \
210 \
211 inline PInPersist& operator >> (PInPersist& c, _Type_& data) \
212 { \
213 c.GetBytes(&data._field_, _size_); \
214 return c; \
215 }
216
217#endif
218
219//! \endcond
220
221// --- Cela risque d'etre dangereux --- On le laisse au niveau des DataObj
222// Reza 24/3/2000
223// inline POutPersist& operator << (POutPersist& c, PPersist const& obj)
224// {
225// obj.Write(c);
226// return c;
227// }
228
229// inline PInPersist& operator >> (PInPersist& c, PPersist& obj)
230// {
231// obj.Read(c);
232// return c;
233// }
234
235 // Utility class to
236 // - compute the class ID from a MD5 hash of the class name
237 // - register classes with PIOPersist, through PPRegister macro
238
239//! template class for handling the PPersist registration mechanism.
240 template <class T>
241 class PPersistRegistrar {
242 public:
243 static PPersist* Create() {return new T();}
244 static void Register(string id) { PIOPersist::RegisterPPHandlerClass(Hash(id), typeid(T).name(), Create); }
245 static uint_8 Hash(string id) {
246 return PIOPersist::Hash(id);
247 }
248 };
249
250#define PPRegister(className) PPersistRegistrar< className >::Register( #className );
251#define DObjRegister(ppclassName, className) PIOPersist::RegisterDataObjClass(PIOPersist::Hash(#ppclassName), typeid(className).name());
252
253} // namespace SOPHYA
254
255// La classe PPFNameTag facilite la manipulation des Nametag ds les fichiers
256// PPersist - definie ds ppfnametag.h
257#include "ppfnametag.h"
258
259
260#endif
Note: See TracBrowser for help on using the repository browser.