variant.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <string>
#include <vector>
#include <variant>
 
 
namespace itk::opc {
 
class Variant {
public:
  inline bool operator == (const Variant& var) const { return var.val == val; }
  inline bool operator != (const Variant& var) const { return !(*this == var); }
 
  template<typename T>
  inline T& get() { return std::get<T>(val); }
 
  template<typename T>
  inline void set(const T& value) { val = value; }
 
  template<typename T>
  inline bool is_type() { return std::holds_alternative<T>(val); }
 
  inline bool     &get_bool()   { return std::get<bool>(val); }
  inline int8_t   &get_int8()   { return std::get<int8_t>(val); }
  inline int16_t  &get_int16()  { return std::get<int16_t>(val); }
  inline int32_t  &get_int32()  { return std::get<int32_t>(val); }
  inline int64_t  &get_int64()  { return std::get<int64_t>(val); }
  inline uint8_t  &get_uint8()  { return std::get<uint8_t>(val); }
  inline uint16_t &get_uint16() { return std::get<uint16_t>(val); }
  inline uint32_t &get_uint32() { return std::get<uint32_t>(val); }
  inline uint64_t &get_uint64() { return std::get<uint64_t>(val); }
  inline float    &get_float()  { return std::get<float>(val); }
  inline double   &get_double() { return std::get<double>(val); }
  inline std::string &get_string() { return std::get<std::string>(val); }
 
  inline void set(bool value)     { set<bool>(value); }
  inline void set(int8_t value)   { set<int8_t>(value); }
  inline void set(int16_t value)  { set<int16_t>(value); }
  inline void set(int32_t value)  { set<int32_t>(value); }
  inline void set(int64_t value)  { set<int64_t>(value); }
  inline void set(uint8_t value)  { set<uint8_t>(value); }
  inline void set(uint16_t value) { set<uint16_t>(value); }
  inline void set(uint32_t value) { set<uint32_t>(value); }
  inline void set(uint64_t value) { set<uint64_t>(value); }
  inline void set(float value)    { set<float>(value); }
  inline void set(double value)   { set<double>(value); }
  inline void set(const std::string& value) { set<std::string>(value); }
 
  inline bool undefined() {
    return std::holds_alternative<std::monostate>(val);
  }
  inline bool is_bool()  { return is_type<bool>(); }
  inline bool is_int8()  { return is_type<int8_t>(); }
  inline bool is_int16() { return is_type<int16_t>(); }
  inline bool is_int32() { return is_type<int32_t>(); }
  inline bool is_int64() { return is_type<int64_t>(); }
  inline bool is_uint8()  { return is_type<uint8_t>(); }
  inline bool is_uint16() { return is_type<uint16_t>(); }
  inline bool is_uint32() { return is_type<uint32_t>(); }
  inline bool is_uint64() { return is_type<uint64_t>(); }
  inline bool is_float() { return is_type<float>(); }
  inline bool is_double() { return is_type<double>(); }
  inline bool is_string() { return is_type<std::string>(); }
 
  inline bool is_int() {
    return is_int8() || is_int16() || is_int32() || is_int64();
  }
 
  inline bool is_uint() {
    return is_uint8() || is_uint16() || is_uint32() || is_uint64();
  }
 
  inline bool is_real() {
    return is_float() || is_double();
  }
 
  inline int64_t as_int() {
    if (is_int8())  return get_int8();
    if (is_int16()) return get_int16();
    if (is_int32()) return get_int32();
    return get_int64();
  }
 
  inline uint64_t as_uint() {
    if (is_uint8())  return get_uint8();
    if (is_uint16()) return get_uint16();
    if (is_uint32()) return get_uint32();
    return get_uint64();
  }
 
  inline double as_real() {
    if (is_float()) return get_float();
    return get_double();
  }
 
  std::variant<
    std::monostate,
    bool,
    int8_t,  uint8_t,
    int16_t, uint16_t,
    int32_t, uint32_t,
    int64_t, uint64_t,
    float, double,
    std::string,
    std::vector<int8_t>,
    std::vector<uint8_t>,
    std::vector<int16_t>,
    std::vector<uint16_t>,
    std::vector<int32_t>,
    std::vector<uint32_t>,
    std::vector<int64_t>,
    std::vector<uint64_t>
  > val;
 
}; // Variant
 
} // itk::opc