variant.h

Go to the documentation of this file.

/* 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:
    AJAVariant();
    explicit AJAVariant(AJAVariantType type);
    explicit AJAVariant(bool value);
    explicit AJAVariant(float value);
    explicit AJAVariant(double value);
    explicit AJAVariant(int8_t value);
    explicit AJAVariant(uint8_t value);
    explicit AJAVariant(int16_t value);
    explicit AJAVariant(uint16_t value);
    explicit AJAVariant(int32_t value);
    explicit AJAVariant(uint32_t value);
    explicit AJAVariant(int64_t value);
    explicit AJAVariant(uint64_t value);
    explicit AJAVariant(const char* value);
    explicit AJAVariant(const char* value, size_t length);
    explicit AJAVariant(const std::string& value);
 
    AJAVariant(const AJAVariant& other);
    ~AJAVariant() {}
 
    void operator=(const AJAVariant& other);
    
    // Type conversion operators
    operator bool() const;
    operator float() const;
    operator double() const;
    operator int8_t() const;
    operator uint8_t() const;
    operator int16_t() const;
    operator uint16_t() const;
    operator int32_t() const;
    operator uint32_t() const;
    operator int64_t() const;
    operator uint64_t() const;
    operator std::string() const;
 
    AJAVariantType GetType() const { return mType; }
 
    bool GetBool() const;
    float GetFloat() const;
    double GetDouble() const;
    int8_t GetInt8() const;
    uint8_t GetUInt8() const;
    int16_t GetInt16() const;
    uint16_t GetUInt16() const;
    int32_t GetInt32() const;
    uint32_t GetUInt32() const;
    int64_t GetInt64() const;
    uint64_t GetUInt64() const;
    const std::string& GetString() const;
 
    void SetBool(bool value);
    void SetFloat(float value);
    void SetDouble(double value);
    void SetInt8(int8_t value);
    void SetUInt8(uint8_t value);
    void SetInt16(int16_t value);
    void SetUInt16(uint16_t value);
    void SetInt32(int32_t value);
    void SetUInt32(uint32_t value);
    void SetInt64(int64_t value);
    void SetUInt64(uint64_t value);
    void SetString(const char* value);
    void SetString(const char* value, size_t length);
    void SetString(const std::string& value);
 
    // 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;
    };
    std::string mStringValue;
};
 
typedef std::vector<AJAVariant> AJAVariantList;
 
#endif