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