variant.h

Go to the documentation of this file.

 
#ifndef _A_UTILS_UTIL_VARIANT_VARIANT_HEADER_INCLUDED_
#define _A_UTILS_UTIL_VARIANT_VARIANT_HEADER_INCLUDED_
 
#include <memory>
#include <string>
#include <cstdint>
 
namespace a_util {
namespace variant {
typedef enum {
    VT_Empty = 0,           
    VT_Bool = 1,            
    VT_Int8 = 2,            
    VT_UInt8 = 3,           
    VT_Int16 = 4,           
    VT_UInt16 = 5,          
    VT_Int32 = 6,           
    VT_UInt32 = 7,          
    VT_Int64 = 8,           
    VT_UInt64 = 9,          
    VT_Float = 10,          
    VT_Double = 11,         
    VT_String = 12,         
    VT_Float32 = VT_Float,  
    VT_Float64 = VT_Double, 
} VariantType;

class Variant {
public:
    Variant();
    Variant(bool value);
    Variant(std::int8_t value);
    Variant(std::uint8_t value);
    Variant(std::int16_t value);
    Variant(std::uint16_t value);
    Variant(std::int32_t value);
    Variant(std::uint32_t value);
    Variant(std::int64_t value);
    Variant(std::uint64_t value);
    Variant(float value);
    Variant(double value);
    Variant(const char* value);

    Variant(const Variant& other);

    Variant& operator=(const Variant& other);

    ~Variant();

    Variant(Variant&& other) noexcept;

    Variant& operator=(Variant&& other) noexcept;

    VariantType getType() const;

    std::size_t getArraySize() const;

    std::size_t getStringSize() const;

    bool isArray() const;

    bool isEmpty() const;

    void reset();

    void reset(bool value);
    void reset(std::int8_t value);
    void reset(std::uint8_t value);
    void reset(std::int16_t value);
    void reset(std::uint16_t value);
    void reset(std::int32_t value);
    void reset(std::uint32_t value);
    void reset(std::int64_t value);
    void reset(std::uint64_t value);
    void reset(float value);
    void reset(double value);
    void reset(const char* value);

    void reset(const bool* array_storage, std::size_t array_size);
    void reset(const std::int8_t* array_storage, std::size_t array_size);
    void reset(const std::uint8_t* array_storage, std::size_t array_size);
    void reset(const std::int16_t* array_storage, std::size_t array_size);
    void reset(const std::uint16_t* array_storage, std::size_t array_size);
    void reset(const std::int32_t* array_storage, std::size_t array_size);
    void reset(const std::uint32_t* array_storage, std::size_t array_size);
    void reset(const std::int64_t* array_storage, std::size_t array_size);
    void reset(const std::uint64_t* array_storage, std::size_t array_size);
    void reset(const float* array_storage, std::size_t array_size);
    void reset(const double* array_storage, std::size_t array_size);

    bool getBool(std::size_t array_index = 0) const;
    std::int8_t getInt8(std::size_t array_index = 0) const;
    std::uint8_t getUInt8(std::size_t array_index = 0) const;
    std::int16_t getInt16(std::size_t array_index = 0) const;
    std::uint16_t getUInt16(std::size_t array_index = 0) const;
    std::int32_t getInt32(std::size_t array_index = 0) const;
    std::uint32_t getUInt32(std::size_t array_index = 0) const;
    std::int64_t getInt64(std::size_t array_index = 0) const;
    std::uint64_t getUInt64(std::size_t array_index = 0) const;
    float getFloat(std::size_t array_index = 0) const;
    double getDouble(std::size_t array_index = 0) const;
    float getFloat32(std::size_t array_index = 0) const;
    double getFloat64(std::size_t array_index = 0) const;
    const char* getString() const;

    bool asBool() const;
    std::int8_t asInt8() const;
    std::uint8_t asUInt8() const;
    std::int16_t asInt16() const;
    std::uint16_t asUInt16() const;
    std::int32_t asInt32() const;
    std::uint32_t asUInt32() const;
    std::int64_t asInt64() const;
    std::uint64_t asUInt64() const;
    float asFloat() const;
    double asDouble() const;
    std::string asString() const;

    operator bool() const;
    operator std::int8_t() const;
    operator std::uint8_t() const;
    operator std::int16_t() const;
    operator std::uint16_t() const;
    operator std::int32_t() const;
    operator std::uint32_t() const;
    operator std::int64_t() const;
    operator std::uint64_t() const;
    operator float() const;
    operator double() const;
    operator std::string() const;

    Variant& operator=(bool value);
    Variant& operator=(std::int8_t value);
    Variant& operator=(std::uint8_t value);
    Variant& operator=(std::int16_t value);
    Variant& operator=(std::uint16_t value);
    Variant& operator=(std::int32_t value);
    Variant& operator=(std::uint32_t value);
    Variant& operator=(std::int64_t value);
    Variant& operator=(std::uint64_t value);
    Variant& operator=(float value);
    Variant& operator=(double value);
    Variant& operator=(const char* value);

    friend bool operator==(const Variant& lhs, const Variant& rhs);
 
private:
    class Implementation;
    std::unique_ptr<Implementation> _impl;
};

bool operator!=(const Variant& lhs, const Variant& rhs);
 
} // namespace variant
} // namespace a_util
 
#endif // _A_UTILS_UTIL_VARIANT_VARIANT_HEADER_INCLUDED_