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