variant.h

Go to the documentation of this file.

#pragma once

#include "avect.h"
#include "basestring.h"
#include "type_selector.h"
#include "vect.h"
#include <cassert>
#pragma warning (disable:809)

class QDataStream;

#pragma warning(push)
#pragma warning(disable:26812) // Non-class enum
#pragma warning(disable:26495) // Unitiailized value in a union
class Variant {
  template <class T> friend class VUserType; // need this so that VUserType can access dataSize_
private:
  class UserTypeBase {
  public:
    UserTypeBase() { }
    virtual ~UserTypeBase() { }
    virtual UserTypeBase *clone(char *data) const=0;
    virtual void copy(const UserTypeBase *base)=0;
  };

  #ifdef _WIN64
#  ifdef _DEBUG
  static const int dataSize_ = 80;
#  else
  static const int dataSize_ = 72;
#  endif
#else
#  ifdef _DEBUG
  static const int dataSize_ = 40;
#  else
  static const int dataSize_ = 36;
#  endif
#endif
public:
  template <typename T> class VUserType;

  friend BASE_EXPORT QDataStream &operator<<(QDataStream &,const Variant &);

  enum Type { ByteType=1,     
              UByteType,      
              ShortType,      
              UShortType,     
              IntType,        
              UIntType,       
              LongType,       
              ULongType,      
              FloatType,      
              DoubleType,     
              VoidType,       
              BoolType,       
              IVect2Type,     
              DVect2Type,     
              IVect3Type,     
              DVect3Type,     
              RawDataType,    
              StringType=100, 
              UserType        
            };
  BASE_EXPORT Variant(const Variant &mv) : type_(IntType) { operator=(mv); }
  BASE_EXPORT Variant(const Int &v=0) : type_(IntType), int_(v) { }
  BASE_EXPORT Variant(const bool &v) : type_(BoolType), bool_(v) { }
  BASE_EXPORT Variant(const Byte &v) : type_(ByteType), byte_(v) { }  
  BASE_EXPORT Variant(const UByte &v) : type_(UByteType), ubyte_(v) { }   
  BASE_EXPORT Variant(const Short &v) : type_(ShortType), short_(v) { }  
  BASE_EXPORT Variant(const UShort &v) : type_(UShortType), ushort_(v) { }  
  BASE_EXPORT Variant(const UInt &v) : type_(UIntType), uint_(v) { }  
  BASE_EXPORT Variant(const Long &v) : type_(LongType), long_(v) { }  
  BASE_EXPORT Variant(const ULong &v) : type_(ULongType), ulong_(v) { }  
  BASE_EXPORT Variant(const Float &v) : type_(FloatType), float_(v) { }  
  BASE_EXPORT Variant(const Double &v) : type_(DoubleType), double_(v) { }  
  BASE_EXPORT Variant(void *v) : type_(VoidType), void_(v) { }  
  BASE_EXPORT Variant(const void *v) : type_(VoidType), void_(const_cast<void *>(v)) { }  
  BASE_EXPORT Variant(const IVect2 &v) : type_(IVect2Type) { conv<IVect2>() = v; }  
  BASE_EXPORT Variant(const DVect2 &v) : type_(DVect2Type) { conv<DVect2>() = v; }  
  BASE_EXPORT Variant(const IVect3 &v) : type_(IVect3Type) { conv<IVect3>() = v; }  
  BASE_EXPORT Variant(const DVect3 &v) : type_(DVect3Type) { conv<DVect3>() = v; }  
  BASE_EXPORT Variant(const String &v); 
  BASE_EXPORT Variant(const Char *v); 
  BASE_EXPORT ~Variant() { del(); }
  BASE_EXPORT const Variant &operator=(const Variant &mv);

  BASE_EXPORT Type   getType() const { return type_; }
  BASE_EXPORT String getTypeName() const { return getTypeName(getType()); }

  BASE_EXPORT bool   toBool(bool *success=0) const; 
  BASE_EXPORT Byte   toByte(bool *success=0) const;   
  BASE_EXPORT UByte  toUByte(bool *success=0) const;  
  BASE_EXPORT Short  toShort(bool *success=0) const;  
  BASE_EXPORT UShort toUShort(bool *success=0) const; 
  BASE_EXPORT Int    toInt(bool *success=0) const;    
  BASE_EXPORT UInt   toUInt(bool *success=0) const;   
  BASE_EXPORT Long   toLong(bool *success=0) const;   
  BASE_EXPORT ULong  toULong(bool *success=0) const;  
  BASE_EXPORT Float  toFloat(bool *success=0) const;  
  BASE_EXPORT Double toDouble(bool *success=0) const; 
  BASE_EXPORT String toString(bool *success=0) const; 
  BASE_EXPORT void * toVoid(bool *success=0) const;   
  BASE_EXPORT IVect2 toIVect2(bool *success=0) const; 
  BASE_EXPORT DVect2 toDVect2(bool *success=0) const; 
  BASE_EXPORT IVect3 toIVect3(bool *success=0) const; 
  BASE_EXPORT DVect3 toDVect3(bool *success=0) const; 

  BASE_EXPORT const Int &   fastToInt() const { return int_; }
  BASE_EXPORT const bool &  fastToBool() const { return bool_; }                                      
  BASE_EXPORT const Long &  fastToLong() const { return long_; }                                    
  BASE_EXPORT const Double &fastToDouble() const { return double_; }                                
  BASE_EXPORT const DVect2 &fastToDVect2() const { return conv<DVect2>(); }                         
  BASE_EXPORT const DVect3 &fastToDVect3() const { return conv<DVect3>(); }                         
  BASE_EXPORT const String &fastToString() const;                                                   

  const Variant &operator=(const bool &v)       { del(); type_ = BoolType;   bool_ = v;   return *this; }
  const Variant &operator=(const Byte &v)       { del(); type_ = ByteType;   byte_ = v;   return *this; }  
  const Variant &operator=(const UByte &v)      { del(); type_ = UByteType;  ubyte_ = v;  return *this; }  
  const Variant &operator=(const Short &v)      { del(); type_ = ShortType;  short_ = v;  return *this; }  
  const Variant &operator=(const UShort &v)     { del(); type_ = UShortType; ushort_ = v; return *this; }  
  const Variant &operator=(const Int &v)        { del(); type_ = IntType;    int_ = v;    return *this; }  
  const Variant &operator=(const UInt &v)       { del(); type_ = UIntType;   uint_ = v;   return *this; }  
  const Variant &operator=(const Long &v)       { del(); type_ = LongType;   long_ = v;   return *this; }  
  const Variant &operator=(const ULong &v)      { del(); type_ = ULongType;  ulong_ = v;  return *this; }  
  const Variant &operator=(const Float &v)      { del(); type_ = FloatType;  float_ = v;  return *this; }  
  const Variant &operator=(const Double &v)     { del(); type_ = DoubleType; double_ = v; return *this; }  
  const Variant &operator=(void *v)             { del(); type_ = VoidType;   void_ = v;   return *this; }  
  const Variant &operator=(const void *v)       { del(); type_ = VoidType;   void_ = const_cast<void *>(v);   return *this; } 
  const Variant &operator=(const IVect2 &v)     { del(); type_ = IVect2Type; conv<IVect2>() = v; return *this; }  
  const Variant &operator=(const DVect2 &v)     { del(); type_ = DVect2Type; conv<DVect2>() = v; return *this; }  
  const Variant &operator=(const DAVect2 &v)    { del(); type_ = DoubleType; double_ = v.z(); return *this; }  
  const Variant &operator=(const IVect3 &v)     { del(); type_ = IVect3Type; conv<IVect3>() = v; return *this; }  
  const Variant &operator=(const DVect3 &v)     { del(); type_ = DVect3Type; conv<DVect3>() = v; return *this; }  
  BASE_EXPORT const Variant &operator=(const String &v);  
  const Variant &operator=(const Char *v)       { return operator=(String(v)); }  

  BASE_EXPORT void        setToRawData();
  char *      getRawData() { return data_; }
  const char *getRawData() const { return data_; }  

  template <class T> void     setToUserType(const T &t);

  template <class T> void     moveToUserType(T && t);

  template <class T> T& convertToUserType();

  template <class T> T        toUserType() const;
  template <class T> T &      fastToUserType() { return conv<VUserType<T> >().value(); }
  template <class T> const T &fastToUserType() const { return conv<VUserType<T> >().value(); }  
  template <class T> bool     isUserType() const { return getType()==VUserType<T>::typeNumber_; }
  static BASE_EXPORT String  getTypeName(Type type);
  static BASE_EXPORT int     getRawDataSize() { return dataSize_; }
  static BASE_EXPORT bool    getUserTypeClaimed(int type);
  template <class T> static bool registerType(int type,const String &name);
  
private:
  static const int version_;
  bool isSpecialType() const { return type_ >= StringType; }

  static BASE_EXPORT bool claimUserType(int type,const String &name);

  template <class T> T &conv() { return *reinterpret_cast<T *>(data_); }
  template <class T> const T &conv() const { return *reinterpret_cast<const T *>(data_); }
  void del() { if (isSpecialType()) conv<UserTypeBase>().~UserTypeBase(); }

  Type type_;
  union {
    Byte   byte_;
    UByte  ubyte_;
    Short  short_;
    UShort ushort_;
    Int    int_;
    UInt   uint_;
    Long   long_;
    ULong  ulong_;
    Float  float_;
    Double double_;
    void * void_;
    bool   bool_;
    char   data_[dataSize_];
  };
};
#pragma warning(pop)

template <> class Variant::VUserType<void *> : public Variant::UserTypeBase {
public:
  VUserType() : t_(nullptr) { }
  VUserType(void * const t) : t_(t) { }
  virtual ~VUserType() { }
  virtual VUserType<void *> *clone(char *data) const { return new(data) VUserType<void *>(t_); }
  virtual void copy(const UserTypeBase *base)
  {
    const VUserType<void *> *p = reinterpret_cast<const VUserType<void *> *>(base);
    if (!p) return;
    t_ = p->t_;
  }

  static bool isValue () { return true; } 
  void * t_;  
  static int typeNumber_; 
};

template <typename T> class Variant::VUserType : public Variant::UserTypeBase, public itasca::conditional_container<sizeof(T) + sizeof(Variant::VUserType<void *>) - sizeof(void *) <= Variant::dataSize_, T>
{
public:
  VUserType(const T &t=T()) : itasca::conditional_container<sizeof(T) + sizeof(VUserType<void *>) - sizeof(void *) <= Variant::dataSize_, T>(t) {};
  VUserType(T && t) : itasca::conditional_container<sizeof(T) + sizeof(VUserType<void *>) - sizeof(void *) <= Variant::dataSize_, T>(std::move(t)) {};
  virtual ~VUserType() {}
  virtual VUserType<T> *clone(char *data) const { return new(data) VUserType<T>(this->value()); }
  virtual void copy(const UserTypeBase *base)
  {
    const VUserType<T> *p = reinterpret_cast<const VUserType<T> *>(base);
    if (!p) return;
    operator=(*p);
  }

  static int typeNumber_; 
};


template <class T> inline void Variant::setToUserType(const T &t)
{
  if (getType()!=VUserType<T>::typeNumber_)
  {
    del();
    new(data_) VUserType<T>(t);
    type_ = static_cast<Type>(VUserType<T>::typeNumber_);
    return;
  }
  conv<VUserType<T>>() = t;
}

template <class T> inline void Variant::moveToUserType(T && t) {
  if ( getType() != VUserType<T>::typeNumber_ ) {
    del();
    new(data_) VUserType<T>(std::move(t));
    type_ = static_cast<Type>(VUserType<T>::typeNumber_);
    return;
  }
  conv<VUserType<T>>() = std::move(t);
}

template <class T> inline T Variant::toUserType() const {
  if (getType()!=VUserType<T>::typeNumber_)
    return T();
  return conv<VUserType<T>>().VUserType<T>::value();
}

template <class T> T& Variant::convertToUserType() {
    if (getType() != VUserType<T>::typeNumber_) {
        del();
        new(data_) VUserType<T>();
        type_ = static_cast<Type>(VUserType<T>::typeNumber_);
    }
    VUserType<T>& v = conv<VUserType<T>>();
    return v.value();
}

template <class T> bool Variant::registerType(int typeNumber,const String &name) {
  //if ( sizeof(VUserType<T>) > dataSize_ ) { throw std::exception("ERROR: Type too large for variant."); }
  static_assert(sizeof(VUserType<T>) <= dataSize_, "ERROR: Type too large for variant.");
  if (!claimUserType(typeNumber,name)) return false;
  VUserType<T>::typeNumber_ = typeNumber;
  return true;
}

// EOF