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>
 
class QDataStream;
 
#ifndef __GNUC__
#pragma warning(push)
#pragma warning(disable:26450) // Clang overflow warning
#pragma warning(disable:26495) // Clang initialize in union
#pragma warning(disable:26812) // Non-class enum
#pragma warning(disable:26495) // Unitiailized value in a union
#endif
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 class Type {
 Byte = 1, 
 UByte, 
 Short, 
 UShort, 
 Int, 
 UInt, 
 Long, 
 ULong, 
 Float, 
 Double, 
 Void, 
 Bool, 
 IVect2, 
 DVect2, 
 IVect3, 
 DVect3, 
 RawData, 
 String = 100, 
 User 
 };
 BASE_EXPORT Variant(const Variant &mv) : type_(Type::Int) { operator=(mv); }
 BASE_EXPORT Variant(const int32 &v = 0) : type_(Type::Int), int_(v) {}
 BASE_EXPORT Variant(const bool &v) : type_(Type::Bool), bool_(v) {}
 BASE_EXPORT Variant(const int8 &v) : type_(Type::Byte), byte_(v) {} 
 BASE_EXPORT Variant(const uint8 &v) : type_(Type::UByte), ubyte_(v) {} 
 BASE_EXPORT Variant(const int16 &v) : type_(Type::Short), short_(v) {} 
 BASE_EXPORT Variant(const uint16 &v) : type_(Type::UShort), ushort_(v) {} 
 BASE_EXPORT Variant(const uint32 &v) : type_(Type::UInt), uint_(v) {} 
 BASE_EXPORT Variant(const int64 &v) : type_(Type::Long), long_(v) {} 
 BASE_EXPORT Variant(const uint64 &v) : type_(Type::ULong), ulong_(v) {} 
 BASE_EXPORT Variant(const float &v) : type_(Type::Float), float_(v) {} 
 BASE_EXPORT Variant(const double &v) : type_(Type::Double), double_(v) {} 
 BASE_EXPORT Variant(void *v) : type_(Type::Void), void_(v) {} 
 BASE_EXPORT Variant(const void *v) : type_(Type::Void), void_(const_cast<void *>(v)) {} 
 BASE_EXPORT Variant(const IVect2 &v) : type_(Type::IVect2) { conv<IVect2>() = v; } 
 BASE_EXPORT Variant(const DVect2 &v) : type_(Type::DVect2) { conv<DVect2>() = v; } 
 BASE_EXPORT Variant(const IVect3 &v) : type_(Type::IVect3) { conv<IVect3>() = v; } 
 BASE_EXPORT Variant(const DVect3 &v) : type_(Type::DVect3) { 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 int8 toByte(bool *success = 0) const; 
 BASE_EXPORT uint8 toUByte(bool *success = 0) const; 
 BASE_EXPORT int16 toShort(bool *success = 0) const; 
 BASE_EXPORT uint16 toUShort(bool *success = 0) const; 
 BASE_EXPORT int32 toInt(bool *success = 0) const; 
 BASE_EXPORT uint32 toUInt(bool *success = 0) const; 
 BASE_EXPORT int64 toLong(bool *success = 0) const; 
 BASE_EXPORT uint64 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 int32 &fastToInt() const { return int_; }
 BASE_EXPORT const bool &fastToBool() const { return bool_; } 
 BASE_EXPORT const int64 &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_ = Type::Bool; bool_ = v; return *this; }
 const Variant &operator=(const int8 &v) { del(); type_ = Type::Byte; byte_ = v; return *this; } 
 const Variant &operator=(const uint8 &v) { del(); type_ = Type::UByte; ubyte_ = v; return *this; } 
 const Variant &operator=(const int16 &v) { del(); type_ = Type::Short; short_ = v; return *this; } 
 const Variant &operator=(const uint16 &v) { del(); type_ = Type::UShort; ushort_ = v; return *this; } 
 const Variant &operator=(const int32 &v) { del(); type_ = Type::Int; int_ = v; return *this; } 
 const Variant &operator=(const uint32 &v) { del(); type_ = Type::UInt; uint_ = v; return *this; } 
 const Variant &operator=(const int64 &v) { del(); type_ = Type::Long; long_ = v; return *this; } 
 const Variant &operator=(const uint64 &v) { del(); type_ = Type::ULong; ulong_ = v; return *this; } 
 const Variant &operator=(const float &v) { del(); type_ = Type::Float; float_ = v; return *this; } 
 const Variant &operator=(const double &v) { del(); type_ = Type::Double; double_ = v; return *this; } 
 const Variant &operator=(void *v) { del(); type_ = Type::Void; void_ = v; return *this; } 
 const Variant &operator=(const void *v) { del(); type_ = Type::Void; void_ = const_cast<void *>(v); return *this; } 
 const Variant &operator=(const IVect2 &v) { del(); type_ = Type::IVect2; conv<IVect2>() = v; return *this; } 
 const Variant &operator=(const DVect2 &v) { del(); type_ = Type::DVect2; conv<DVect2>() = v; return *this; } 
 const Variant &operator=(const DAVect2 &v) { del(); type_ = Type::Double; double_ = v.z(); return *this; } 
 const Variant &operator=(const IVect3 &v) { del(); type_ = Type::IVect3; conv<IVect3>() = v; return *this; } 
 const Variant &operator=(const DVect3 &v) { del(); type_ = Type::DVect3; 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_ >= Type::String; }
 
 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_=Type::Int;
 union {
 int8 byte_;
 uint8 ubyte_;
 int16 short_;
 uint16 ushort_;
 int32 int_;
 uint32 uint_;
 int64 long_;
 uint64 ulong_;
 float float_;
 double double_;
 void * void_;
 bool bool_;
 char data_[dataSize_];
 };
};
#ifndef __GNUC__
#pragma warning(pop)
#endif
 
template <> class Variant::VUserType<void *> : public Variant::UserTypeBase {
public:
 VUserType() : t_(nullptr) {}
 VUserType(void *const t) : t_(t) {}
 ~VUserType() override {}
 VUserType<void *> *clone(char *data) const override { return new(data) VUserType<void *>(t_); }
 void copy(const UserTypeBase *base) override {
 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)) {};
 ~VUserType() override {}
 VUserType<T> *clone(char *data) const override { return new(data) VUserType<T>(this->value()); }
 void copy(const UserTypeBase *base) override {
 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