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     };
 166
 167     class YACSLIBENGINE_EXPORT ComposedAny : public Any
 168     {
 169     public:
 170       virtual void setEltAtRank(int i, const Any *elem) throw(Exception) = 0;
 171       AnyPtr operator[](const char *key) const throw(Exception);
 172     protected:
 173       ComposedAny(const ComposedAny& other);
 174       ComposedAny(TypeCode* type, bool isNew=true);
 175     protected:
 176       void checkTypeOf(const Any *elem) const throw(Exception);
 177     private://error methods called during incorrect runtime extraction
 178       int getIntValue() const throw(Exception);
 179       bool getBoolValue() const throw(Exception);
 180       double getDoubleValue() const throw(Exception);
 181       std::string getStringValue() const throw(Exception);
 182     };
 183
 184     typedef SharedPtr<SequenceAny> SequenceAnyPtr;
 185
 186     class YACSLIBENGINE_EXPORT SequenceAny : public ComposedAny
 187     {
 188       friend class TypeCodeSeq;
 189     public:
 190       void clear();
 191       void popBack();
 192       unsigned int size() const { return _alloc.size(); }
 193       void pushBack(const Any *elem);
 194       bool operator ==(const Any& other) const;
 195       void setEltAtRank(int i, const Any *elem) throw(Exception);
 196       AnyPtr operator[](int i) const throw(Exception);
 197       Any *clone() const;
 198       template<class T>
 199       static SequenceAny *New(const std::vector<T>& vec);
 200       static SequenceAny *New(const TypeCode *typeOfContent);
 201       static SequenceAny *New(const TypeCode *typeOfContent, unsigned lgth);
 202       template<class T>
 203       static SequenceAny *New(T *val, unsigned int lgth, Deallocator deAlloc);
 204     protected:
 205       void putMyReprAtPlace(char *data) const;
 206       static void putReprAtPlace(char *data, const char *src, const TypeCode *type, bool deepCpy);
 207       static void destroyReprAtPlace(char *data, const TypeCode *type);
 208       static AnyPtr getOrBuildFromData(char *data, const TypeCode *type);
 209       static bool takeInChargeStorageOf(TypeCode *type);
 210     private:
 211       ~SequenceAny();
 212       SequenceAny(const SequenceAny& other);
 213       SequenceAny(const TypeCode *typeOfContent);
 214       SequenceAny(const TypeCode *typeOfContent, unsigned lgth);
 215       SequenceAny(int *val, unsigned int lgth, Deallocator deAlloc);
 216       SequenceAny(bool *val, unsigned int lgth, Deallocator deAlloc);
 217       SequenceAny(double *val, unsigned int lgth, Deallocator deAlloc);
 218       SequenceAny(const std::vector<int>& val);
 219       SequenceAny(const std::vector<bool>& val);
 220       SequenceAny(const std::vector<double>& val);
 221       SequenceAny(const std::vector<std::string>& val);
 222       void realloc(char *endOfCurrentAllocated, const Any *elem);
 223       char *performCpy(char *srcStart, char *srcFinish, char *destStart);
 224     protected:
 225       SeqAlloc _alloc;
 226     };
 227
 228     typedef SharedPtr<ArrayAny> ArrayAnyPtr;
 229
 230     class YACSLIBENGINE_EXPORT ArrayAny : public ComposedAny
 231     {
 232       friend class TypeCodeArray;
 233     public:
 234       void setEltAtRank(int i, const Any *elem) throw(Exception);
 235       bool operator ==(const Any& other) const;
 236       AnyPtr operator[](int i) const throw(Exception);
 237       unsigned int size() const;
 238       Any *clone() const;
 239       template<class T>
 240       static ArrayAny *New(const std::vector<T>& vec);
 241       template<class T>
 242       static ArrayAny *New(const T *val, unsigned int lgth);
 243       static ArrayAny *New(const TypeCode *typeOfContent, unsigned int lgth);
 244     protected:
 245       void putMyReprAtPlace(char *data) const;
 246       static void putReprAtPlace(char *data, const char *src, const TypeCodeArray *type, bool deepCpy);
 247       static void destroyReprAtPlace(char *data, const TypeCodeArray *type);
 248       static AnyPtr getOrBuildFromData(char *data, const TypeCodeArray *type);
 249       static bool takeInChargeStorageOf(TypeCode *type);
 250     private:
 251       ~ArrayAny();
 252       ArrayAny(const TypeCode *typeOfContent, unsigned int lgth);
 253       ArrayAny(char *data, TypeCodeArray * type);
 254       ArrayAny(const ArrayAny& other);
 255       ArrayAny(const int *val, unsigned int lgth);
 256       ArrayAny(const bool *val, unsigned int lgth);
 257       ArrayAny(const double *val, unsigned int lgth);
 258       ArrayAny(const std::vector<int>& val);
 259       ArrayAny(const std::vector<double>& val);
 260       ArrayAny(const std::vector<std::string>& val);
 261     protected:
 262       char *_data;
 263     };
 264
 265     typedef SharedPtr<StructAny> StructAnyPtr;
 266
 267     class YACSLIBENGINE_EXPORT StructAny : public ComposedAny
 268     {
 269       friend class TypeCodeStruct;
 270     public:
 271       Any *clone() const;
 272       bool operator ==(const Any& other) const;
 273       static StructAny *New(TypeCodeStruct *type);
 274       AnyPtr operator[](int i) const throw(Exception);
 275       AnyPtr operator[](const char *key) const throw(Exception);
 276       void setEltAtRank(int i, const Any *elem) throw(Exception);
 277       void setEltAtRank(const char *key, const Any *elem) throw(Exception);
 278     protected:
 279       void putMyReprAtPlace(char *data) const;
 280       static void putReprAtPlace(char *data, const char *src, const TypeCodeStruct *type, bool deepCpy);
 281       static void destroyReprAtPlace(char *data, const TypeCodeStruct *type);
 282       static AnyPtr getOrBuildFromData(char *data, const TypeCodeStruct *type);
 283     private:
 284       ~StructAny();
 285       StructAny(TypeCodeStruct *type);
 286       StructAny(const StructAny& other);
 287       StructAny(char *data, TypeCodeStruct * type);
 288     private:
 289       char *_data;
 290     };
 291
 292     template<class T>
 293     SequenceAny *SequenceAny::New(T *val, unsigned int lgth, Deallocator deAlloc)
 294     {
 295       return new SequenceAny(val,lgth,deAlloc);
 296     }
 297
 298     template<class T>
 299     SequenceAny *SequenceAny::New(const std::vector<T>& vec)
 300     {
 301       return new SequenceAny(vec);
 302     }
 303
 304     template<class T>
 305     ArrayAny *ArrayAny::New(const std::vector<T>& vec)
 306     {
 307       return new ArrayAny(vec);
 308     }
 309
 310     template<class T>
 311     ArrayAny *ArrayAny::New(const T *val, unsigned int lgth)
 312     {
 313       return new ArrayAny(val,lgth);
 314     }
 315   }
 316 }
 317
 318 #endif