d6/d10/variant_8h_source.html

/* SPDX-License-Identifier: MIT */

#ifndef AJA_VARIANT_H

#define AJA_VARIANT_H


#include "ajabase/common/public.h"

#include <vector>


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