variant.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#ifndef AJA_VARIANT_H
#define AJA_VARIANT_H
 
#include "ajabase/common/export.h"
#include <string>
#include <vector>
#include <cstdint>
 
typedef enum
{
    AJA_VARIANT_NONE,
    AJA_VARIANT_BOOL,
    AJA_VARIANT_FLOAT,
    AJA_VARIANT_DOUBLE,
    AJA_VARIANT_INT8,
    AJA_VARIANT_UINT8,
    AJA_VARIANT_INT16,
    AJA_VARIANT_UINT16,
    AJA_VARIANT_INT32,
    AJA_VARIANT_UINT32,
    AJA_VARIANT_INT64,
    AJA_VARIANT_UINT64,
    AJA_VARIANT_STRING,
} AJAVariantType;
 
class AJA_EXPORT AJAVariant
{
public:
    explicit AJAVariant (const AJAVariantType type = AJA_VARIANT_INT32);
    explicit inline AJAVariant (const bool value)       {mType = AJA_VARIANT_BOOL;      mUnion.mBooleanValue = value;}
    explicit inline AJAVariant (const float value)      {mType = AJA_VARIANT_FLOAT;     mUnion.mFloatValue   = value;}
    explicit inline AJAVariant (const double value)     {mType = AJA_VARIANT_DOUBLE;    mUnion.mDoubleValue  = value;}
    explicit inline AJAVariant (const int8_t value)     {mType = AJA_VARIANT_INT8;      mUnion.mInt8Value    = value;}
    explicit inline AJAVariant (const uint8_t value)    {mType = AJA_VARIANT_UINT8;     mUnion.mUInt8Value   = value;}
    explicit inline AJAVariant (const int16_t value)    {mType = AJA_VARIANT_INT16;     mUnion.mInt16Value   = value;}
    explicit inline AJAVariant (const uint16_t value)   {mType = AJA_VARIANT_UINT16;    mUnion.mUInt16Value  = value;}
    explicit inline AJAVariant (const int32_t value)    {mType = AJA_VARIANT_INT32;     mUnion.mInt32Value   = value;}
    explicit inline AJAVariant (const uint32_t value)   {mType = AJA_VARIANT_UINT32;    mUnion.mUInt32Value  = value;}
    explicit inline AJAVariant (const int64_t value)    {mType = AJA_VARIANT_INT64;     mUnion.mInt64Value   = value;}
    explicit inline AJAVariant (const uint64_t value)   {mType = AJA_VARIANT_UINT64;    mUnion.mUInt64Value  = value;}
    explicit inline AJAVariant (const char* pStr)       {mType = AJA_VARIANT_STRING;    mStringValue = pStr;}
    explicit inline AJAVariant (const char* pStr, size_t len)   : mType(AJA_VARIANT_STRING), mStringValue(pStr, len) {}
    explicit inline AJAVariant (const std::string & value)      : mType(AJA_VARIANT_STRING), mStringValue(value) {}
 
    inline AJAVariant (const AJAVariant & other)    {operator=(other);}
 
    ~AJAVariant() {}
 
    AJAVariant & operator = (const AJAVariant & other);
 
    template<typename T> AJAVariant &   operator = (const T inRHS)
                                        {
                                            const AJAVariant v(inRHS);
                                            mType = v.mType;
                                            mUnion = v.mUnion;
                                            mStringValue = v.mStringValue;
                                            return *this;
                                        }
 
    //  Type conversion operators
    inline operator bool() const        {return AsBool();}
    inline operator float() const       {return AsFloat();}
    inline operator double() const      {return AsDouble();}
    inline operator int8_t() const      {return AsInt8();}
    inline operator uint8_t() const     {return AsUInt8();}
    inline operator int16_t() const     {return AsInt16();}
    inline operator uint16_t() const    {return AsUInt16();}
    inline operator int32_t() const     {return AsInt32();}
    inline operator uint32_t() const    {return AsUInt32();}
    inline operator int64_t() const     {return AsInt64();}
    inline operator uint64_t() const    {return AsUInt64();}
    inline operator std::string() const {return AsString();}
 
    inline AJAVariantType GetType() const   {return mType;} 
 
    bool IsNumeric() const;     
    bool IsUnsigned() const;    
    bool IsSigned() const;      
 
    inline bool GetBool() const             {return mUnion.mBooleanValue;}
 
    inline float GetFloat() const           {return mUnion.mFloatValue;}
 
    inline double GetDouble() const         {return mUnion.mDoubleValue;}
 
    inline int8_t GetInt8() const           {return mUnion.mInt8Value;}
 
    inline uint8_t GetUInt8() const         {return mUnion.mUInt8Value;}
 
    inline int16_t GetInt16() const         {return mUnion.mInt16Value;}
 
    inline uint16_t GetUInt16() const       {return mUnion.mUInt16Value;}
 
    inline int32_t GetInt32() const         {return mUnion.mInt32Value;}
 
    inline uint32_t GetUInt32() const       {return mUnion.mUInt32Value;}
 
    inline int64_t GetInt64() const         {return mUnion.mInt64Value;}
 
    inline uint64_t GetUInt64() const       {return mUnion.mUInt64Value;}
 
    inline const std::string & GetString() const    {return mStringValue;}
 
    inline void SetBool(bool value) {mUnion.mBooleanValue = value;  mType = AJA_VARIANT_BOOL;}
    inline void SetFloat(float value)   {mUnion.mFloatValue = value;    mType = AJA_VARIANT_FLOAT;}
    inline void SetDouble(double value) {mUnion.mDoubleValue = value;   mType = AJA_VARIANT_DOUBLE;}
    inline void SetInt8(int8_t value)   {mUnion.mInt8Value = value; mType = AJA_VARIANT_INT8;}
    inline void SetUInt8(uint8_t value) {mUnion.mUInt8Value = value;    mType = AJA_VARIANT_UINT8;}
    inline void SetInt16(int16_t value) {mUnion.mInt16Value = value;    mType = AJA_VARIANT_INT16;}
    inline void SetUInt16(uint16_t value)   {mUnion.mUInt16Value = value;   mType = AJA_VARIANT_UINT16;}
    inline void SetInt32(int32_t value) {mUnion.mInt32Value = value;    mType = AJA_VARIANT_INT32;}
    inline void SetUInt32(uint32_t value)   {mUnion.mUInt32Value = value;   mType = AJA_VARIANT_UINT32;}
    inline void SetInt64(int64_t value) {mUnion.mInt64Value = value;    mType = AJA_VARIANT_INT64;}
    inline void SetUInt64(uint64_t value)   {mUnion.mUInt64Value = value;   mType = AJA_VARIANT_UINT64;}
    inline void SetString(const char* value)    {mStringValue = std::string(value); mType = AJA_VARIANT_STRING;}
    inline void SetString(const char* pStr, const size_t len)   {mStringValue = std::string(pStr, len); mType = AJA_VARIANT_STRING;}
    inline void SetString(const std::string & value)    {mStringValue = value;  mType = AJA_VARIANT_STRING;}
 
    // Type conversion methods
    bool AsBool() const;
    float AsFloat() const;
    double AsDouble() const;
    int8_t AsInt8() const;
    uint8_t AsUInt8() const;
    int16_t AsInt16() const;
    uint16_t AsUInt16() const;
    int32_t AsInt32() const;
    uint32_t AsUInt32() const;
    int64_t AsInt64() const;
    uint64_t AsUInt64() const;
    std::string AsString() const;
 
private:
    void initialize();
 
    AJAVariantType mType;
    union
    {
        bool mBooleanValue;
        float mFloatValue;
        double mDoubleValue;
        int8_t mInt8Value;
        uint8_t mUInt8Value;
        int16_t mInt16Value;
        uint16_t mUInt16Value;
        int32_t mInt32Value;
        uint32_t mUInt32Value;
        int64_t mInt64Value;
        uint64_t mUInt64Value;
    } mUnion;
    std::string mStringValue;
};  //  AJAVariant
 
typedef std::vector<AJAVariant> AJAVariantList;
 
#endif  //  AJA_VARIANT_H