Salome HOME
Retrieve state of ForEachLoop node even in case of failure.
[modules/yacs.git] / src / engine / Any.hxx
1 // Copyright (C) 2006-2014  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #ifndef __YACSANY_HXX__
21 #define __YACSANY_HXX__
22
23 #include "YACSlibEngineExport.hxx"
24 #include "RefCounter.hxx"
25 #include "Exception.hxx"
26 #include "SharedPtr.hxx"
27
28 #include <vector>
29
30 namespace YACS
31 {
32   namespace ENGINE
33   {
34     class Any;
35     class AtomAny;
36     class TypeCode;
37     class SeqAlloc;
38     class ArrayAny;
39     class StructAny;
40     class SequenceAny;
41     class TypeCodeArray;
42     class TypeCodeStruct;
43     typedef void (*Deallocator)(void *);
44
45     class YACSLIBENGINE_EXPORT StringOnHeap
46     {
47       friend class Any;
48       friend class AtomAny;
49       friend class ArrayAny;
50     private:
51       StringOnHeap(const char *val);
52       StringOnHeap(const std::string& val);
53       StringOnHeap(char *val, Deallocator deAlloc);
54       bool operator ==(const StringOnHeap& other) const;
55       StringOnHeap *deepCopy() const;
56       const char *cStr() const { return _str; }
57       ~StringOnHeap();
58     private:
59       char *_str;
60       Deallocator _dealloc;
61     };
62
63     typedef SharedPtr<Any> AnyPtr;
64     
65     /*!
66      * \brief: Interface for management of storage of data formated dynamically in its TypeCode.
67      *         Warning virtual inheritance on Any daughter classes NOT supported.
68      */
69     class YACSLIBENGINE_EXPORT Any : public RefCounter
70     {
71       friend class SeqAlloc;
72       friend class ArrayAny;
73       friend class StructAny;
74       friend class SequenceAny;
75     public:
76       const TypeCode *getType() const { return _type; }
77       //for convenience methods
78       virtual Any *clone() const = 0;
79       virtual AnyPtr operator[](int i) const throw(Exception) = 0;
80       virtual AnyPtr operator[](const char *key) const throw(Exception) = 0;
81       virtual bool operator ==(const Any& other) const = 0;
82       virtual int getIntValue() const throw(Exception) = 0;
83       virtual bool getBoolValue() const throw(Exception) = 0;
84       virtual double getDoubleValue() const throw(Exception) = 0;
85       virtual std::string getStringValue() const throw(Exception) = 0;
86       //
87     protected:
88 #ifndef SWIG
89       virtual ~Any();
90 #endif
91       Any(TypeCode* type);
92       Any(const Any& other);
93       virtual void putMyReprAtPlace(char *data) const = 0;
94       static AnyPtr buildAnyFromCoarseData(char *data, TypeCode* type); //Factory Method
95     protected:
96       TypeCode* _type;
97     };
98
99     typedef SharedPtr<AtomAny> AtomAnyPtr;
100
101     class YACSLIBENGINE_EXPORT AtomAny : public Any
102     {
103       friend class TypeCode;
104
105       union ValueContainer
106       {
107         int _i;
108         bool _b;
109         double _d;
110         StringOnHeap *_s;
111       };
112     public:
113       Any *clone() const;
114       template<class T>
115       static AtomAny *New(T val) { return new AtomAny(val); }
116       static AtomAny *New(char *val, Deallocator dealloc);
117       AnyPtr operator[](int i) const throw(Exception);
118       AnyPtr operator[](const char *key) const throw(Exception);
119       bool operator ==(const Any& other) const;
120       int getIntValue() const throw(Exception);
121       bool getBoolValue() const throw(Exception);
122       double getDoubleValue() const throw(Exception);
123       std::string getStringValue() const throw(Exception);
124     protected:
125       void putMyReprAtPlace(char *data) const;
126       static void putReprAtPlace(char *data, const char *src, const TypeCode *type, bool deepCpy);
127       static void destroyReprAtPlace(char *data, const TypeCode *type);
128       static AnyPtr getOrBuildFromData(char *data, const TypeCode *type);
129       static bool takeInChargeStorageOf(TypeCode *type);
130     private:
131       ~AtomAny();
132       AtomAny(int val);
133       AtomAny(bool val);
134       AtomAny(double val);
135       AtomAny(const char *val);
136       AtomAny(const std::string& val);
137       AtomAny(const AtomAny& other);
138       AtomAny(char *data, TypeCode* type);
139       AtomAny(char *val, Deallocator deAlloc);
140     protected:
141       ValueContainer _value;
142     };
143     
144     class YACSLIBENGINE_EXPORT SeqAlloc 
145     {
146       friend class SequenceAny;
147       
148       char *_start;
149       char *_finish;
150       char *_endOfStorage;
151       Deallocator _notStdDeAlloc;
152       const unsigned int _sizeOf1Elm;
153     private:
154       SeqAlloc(const SeqAlloc& other);
155       SeqAlloc(unsigned int sizeOf1Elm);
156       ~SeqAlloc();
157       void clear();
158       void initCoarseMemory(char *mem, unsigned int size, Deallocator dealloc);
159       void construct(char *pt, const Any *val);
160       void construct(char *pt, const char *val, const TypeCode *tc, bool deepCpy);
161       char *allocate(unsigned int nbOfByte);
162       void destroy(char *pt, const TypeCode *tc);
163       void deallocate(char *pt);
164       unsigned int size() const;
165       std::vector<unsigned int> getSetItems() const;
166       static const char DFT_CHAR_VAR;
167     };
168     
169     class YACSLIBENGINE_EXPORT ComposedAny : public Any
170     {
171     public:
172       virtual void setEltAtRank(int i, const Any *elem) throw(Exception) = 0;
173       AnyPtr operator[](const char *key) const throw(Exception);
174     protected:
175       ComposedAny(const ComposedAny& other);
176       ComposedAny(TypeCode* type, bool isNew=true);
177     protected:
178       void checkTypeOf(const Any *elem) const throw(Exception);
179     private://error methods called during incorrect runtime extraction
180       int getIntValue() const throw(Exception);
181       bool getBoolValue() const throw(Exception);
182       double getDoubleValue() const throw(Exception);
183       std::string getStringValue() const throw(Exception);
184     };
185
186     typedef SharedPtr<SequenceAny> SequenceAnyPtr;
187     
188     class YACSLIBENGINE_EXPORT SequenceAny : public ComposedAny
189     {
190       friend class TypeCodeSeq;
191     public:
192       void clear();
193       void popBack();
194       unsigned int size() const { return _alloc.size(); }
195       void pushBack(const Any *elem);
196       bool operator ==(const Any& other) const;
197       void setEltAtRank(int i, const Any *elem) throw(Exception);
198       AnyPtr operator[](int i) const throw(Exception);
199       Any *clone() const;
200       template<class T>
201       static SequenceAny *New(const std::vector<T>& vec);
202       static SequenceAny *New(const TypeCode *typeOfContent);
203       static SequenceAny *New(const TypeCode *typeOfContent, unsigned lgth);
204       template<class T>
205       static SequenceAny *New(T *val, unsigned int lgth, Deallocator deAlloc);
206       std::vector<unsigned int> getSetItems() const { return _alloc.getSetItems(); }
207       SequenceAny *removeUnsetItemsFromThis() const;
208     protected:
209       void putMyReprAtPlace(char *data) const;
210       static void putReprAtPlace(char *data, const char *src, const TypeCode *type, bool deepCpy);
211       static void destroyReprAtPlace(char *data, const TypeCode *type);
212       static AnyPtr getOrBuildFromData(char *data, const TypeCode *type);
213       static bool takeInChargeStorageOf(TypeCode *type);
214     private:
215       ~SequenceAny();
216       SequenceAny(const SequenceAny& other);
217       SequenceAny(const TypeCode *typeOfContent);
218       SequenceAny(const TypeCode *typeOfContent, unsigned lgth);
219       SequenceAny(int *val, unsigned int lgth, Deallocator deAlloc);
220       SequenceAny(bool *val, unsigned int lgth, Deallocator deAlloc);
221       SequenceAny(double *val, unsigned int lgth, Deallocator deAlloc);
222       SequenceAny(const std::vector<int>& val);
223       SequenceAny(const std::vector<bool>& val);
224       SequenceAny(const std::vector<double>& val);
225       SequenceAny(const std::vector<std::string>& val);
226       void realloc(char *endOfCurrentAllocated, const Any *elem);
227       char *performCpy(char *srcStart, char *srcFinish, char *destStart);
228     protected:
229       SeqAlloc _alloc;
230     };
231     
232     typedef SharedPtr<ArrayAny> ArrayAnyPtr;
233
234     class YACSLIBENGINE_EXPORT ArrayAny : public ComposedAny
235     {
236       friend class TypeCodeArray;
237     public:
238       void setEltAtRank(int i, const Any *elem) throw(Exception);
239       bool operator ==(const Any& other) const;
240       AnyPtr operator[](int i) const throw(Exception);
241       unsigned int size() const;
242       Any *clone() const;
243       template<class T>
244       static ArrayAny *New(const std::vector<T>& vec);
245       template<class T>
246       static ArrayAny *New(const T *val, unsigned int lgth);
247       static ArrayAny *New(const TypeCode *typeOfContent, unsigned int lgth);
248     protected:
249       void putMyReprAtPlace(char *data) const;
250       static void putReprAtPlace(char *data, const char *src, const TypeCodeArray *type, bool deepCpy);
251       static void destroyReprAtPlace(char *data, const TypeCodeArray *type);
252       static AnyPtr getOrBuildFromData(char *data, const TypeCodeArray *type);
253       static bool takeInChargeStorageOf(TypeCode *type);
254     private:
255       ~ArrayAny();
256       ArrayAny(const TypeCode *typeOfContent, unsigned int lgth);
257       ArrayAny(char *data, TypeCodeArray * type);
258       ArrayAny(const ArrayAny& other);
259       ArrayAny(const int *val, unsigned int lgth);
260       ArrayAny(const bool *val, unsigned int lgth);
261       ArrayAny(const double *val, unsigned int lgth);
262       ArrayAny(const std::vector<int>& val);
263       ArrayAny(const std::vector<double>& val);
264       ArrayAny(const std::vector<std::string>& val);
265     protected:
266       char *_data;
267     };
268
269     typedef SharedPtr<StructAny> StructAnyPtr;
270
271     class YACSLIBENGINE_EXPORT StructAny : public ComposedAny
272     {
273       friend class TypeCodeStruct;
274     public:
275       Any *clone() const;
276       bool operator ==(const Any& other) const;
277       static StructAny *New(TypeCodeStruct *type);
278       AnyPtr operator[](int i) const throw(Exception);
279       AnyPtr operator[](const char *key) const throw(Exception);
280       void setEltAtRank(int i, const Any *elem) throw(Exception);
281       void setEltAtRank(const char *key, const Any *elem) throw(Exception);
282     protected:
283       void putMyReprAtPlace(char *data) const;
284       static void putReprAtPlace(char *data, const char *src, const TypeCodeStruct *type, bool deepCpy);
285       static void destroyReprAtPlace(char *data, const TypeCodeStruct *type);
286       static AnyPtr getOrBuildFromData(char *data, const TypeCodeStruct *type);
287     private:
288       ~StructAny();
289       StructAny(TypeCodeStruct *type);
290       StructAny(const StructAny& other);
291       StructAny(char *data, TypeCodeStruct * type);
292     private:
293       char *_data;
294     };
295
296     template<class T>
297     SequenceAny *SequenceAny::New(T *val, unsigned int lgth, Deallocator deAlloc)
298     {
299       return new SequenceAny(val,lgth,deAlloc);
300     }
301
302     template<class T>
303     SequenceAny *SequenceAny::New(const std::vector<T>& vec)
304     {
305       return new SequenceAny(vec);
306     }
307
308     template<class T>
309     ArrayAny *ArrayAny::New(const std::vector<T>& vec)
310     {
311       return new ArrayAny(vec);
312     }
313
314     template<class T>
315     ArrayAny *ArrayAny::New(const T *val, unsigned int lgth)
316     {
317       return new ArrayAny(val,lgth);
318     }
319   }
320 }
321
322 #endif