var.h

Go to the documentation of this file.

// === var.h ===========================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_META_VAR_H
#define SEN_CORE_META_VAR_H
 
// sen
#include "sen/core/base/assert.h"
#include "sen/core/base/duration.h"
#include "sen/core/base/numbers.h"
#include "sen/core/base/timestamp.h"
#include "sen/core/meta/type_traits.h"
 
// std
#include <cstdlib>
#include <map>
#include <memory>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
namespace sen
{


struct Var;
 
//--------------------------------------------------------------------------------------------------------------
// Conversion functions
//--------------------------------------------------------------------------------------------------------------

[[nodiscard]] std::string toJson(const Var& var, int indent = 2);

[[nodiscard]] Var fromJson(const std::string& str);

[[nodiscard]] std::vector<std::uint8_t> toBson(const Var& var);

[[nodiscard]] Var fromBson(const std::vector<std::uint8_t>& bson);

[[nodiscard]] std::vector<std::uint8_t> toCbor(const Var& var);

[[nodiscard]] Var fromCbor(const std::vector<std::uint8_t>& cbor);

[[nodiscard]] std::vector<std::uint8_t> toMsgpack(const Var& var);

[[nodiscard]] Var fromMsgpack(const std::vector<std::uint8_t>& msgpack);

[[nodiscard]] std::vector<std::uint8_t> toUbjson(const Var& var);

[[nodiscard]] Var fromUbjson(const std::vector<std::uint8_t>& ubson);

[[nodiscard]] Duration stringToDuration(const std::string& str);

template <typename To, bool checkedConversion = false>
[[nodiscard]] To getCopyAs(const Var& var);

using VarList = std::vector<Var>;

using VarMap = std::map<std::string, Var, std::less<>>;

using KeyedVar = std::tuple<uint32_t, std::shared_ptr<Var>>;
 
//--------------------------------------------------------------------------------------------------------------
// Var
//--------------------------------------------------------------------------------------------------------------

struct Var
{
  SEN_COPY_MOVE(Var)
 
public:
  using ValueType = std::variant<std::monostate,
                                 int32_t,
                                 uint32_t,
                                 int64_t,
                                 uint64_t,
                                 float32_t,
                                 float64_t,
                                 Duration,
                                 TimeStamp,
                                 uint8_t,
                                 int16_t,
                                 uint16_t,
                                 bool,
                                 std::string,
                                 VarList,
                                 VarMap,
                                 KeyedVar>;
 
public:  // default construction and destruction
  Var() = default;
  ~Var() = default;
 
public:
  template <typename T>
  constexpr Var(T t)  // NOLINT
  {
    if constexpr (std::is_move_constructible_v<T>)
    {
      value_ = ValueType(std::move(t));
    }
    else
    {
      value_ = ValueType(t);
    }
  }
 
public:
  constexpr operator ValueType&() noexcept  // NOLINT
  {
    return value_;
  }

  constexpr operator const ValueType&() const noexcept  // NOLINT
  {
    return value_;
  }
 
public:
  template <typename T>
  [[nodiscard]] constexpr bool holds() const noexcept
  {
    return std::holds_alternative<T>(value_);
  }

  template <typename... Ts>
  [[nodiscard]] constexpr bool holdsAnyOff() const noexcept
  {
    return (holds<Ts>() || ...);
  }

  [[nodiscard]] constexpr bool holdsIntegralValue() const noexcept
  {
    return holdsAnyOff<int32_t, uint32_t, int64_t, uint64_t, uint8_t, int16_t, uint16_t, bool>();
  }

  [[nodiscard]] constexpr bool holdsFloatingPointValue() const noexcept { return holdsAnyOff<float32_t, float64_t>(); }

  [[nodiscard]] constexpr bool isEmpty() const noexcept { return std::holds_alternative<std::monostate>(value_); }

  template <typename T, bool checkedConversion = false>
  [[nodiscard]] T getCopyAs() const
  {
    return ::sen::getCopyAs<T>(*this);
  }

  template <typename T>
  [[nodiscard]] constexpr T& get()
  {
    return std::get<T>(value_);
  }

  template <typename T>
  [[nodiscard]] constexpr const T& get() const
  {
    return std::get<T>(value_);
  }

  template <typename T>
  [[nodiscard]] const T* getIf() const noexcept
  {
    return std::get_if<T>(&value_);
  }

  template <typename T>
  [[nodiscard]] T* getIf() noexcept
  {
    return std::get_if<T>(&value_);
  }

  void swap(Var& rhs) noexcept;
 
  [[nodiscard]] friend bool operator==(const Var& lhs, const Var& rhs) noexcept { return lhs.isEqual(rhs); }
  [[nodiscard]] friend bool operator!=(const Var& lhs, const Var& rhs) noexcept { return !lhs.isEqual(rhs); }
 
private:
  [[nodiscard]] bool isEqual(const Var& rhs) const noexcept;
 
private:
  ValueType value_ {};
};
 
template <typename T>
struct IsVariantMember<T, Var>: public IsVariantMember<T, typename Var::ValueType>
{
};
 
template <typename T>
constexpr bool isVarTypeMemberV = IsVariantMember<T, Var>::value;

[[nodiscard]] const Var& findElement(const VarMap& map, const std::string& key, const std::string& errorMessage);

template <typename T>
[[nodiscard]] T findElementAs(const VarMap& map, const std::string& key, const std::string& errorMessage)
{
  return getCopyAs<T>(findElement(map, key, errorMessage));
}

 
//----------------------------------------------------------------------------------------------------------------------
// Inline implementation
//----------------------------------------------------------------------------------------------------------------------
 
//--------------------------------------------------------------------------------------------------------------
// Helpers
//--------------------------------------------------------------------------------------------------------------
 
namespace impl
{
 
void getCopyAsImpl(const Var& var, std::monostate& val);
void getCopyAsImpl(const Var& var, int32_t& val);
void getCopyAsImpl(const Var& var, uint32_t& val);
void getCopyAsImpl(const Var& var, int64_t& val);
void getCopyAsImpl(const Var& var, uint64_t& val);
void getCopyAsImpl(const Var& var, float32_t& val);
void getCopyAsImpl(const Var& var, float64_t& val);
void getCopyAsImpl(const Var& var, Duration& val);
void getCopyAsImpl(const Var& var, TimeStamp& val);
void getCopyAsImpl(const Var& var, uint8_t& val);
void getCopyAsImpl(const Var& var, int16_t& val);
void getCopyAsImpl(const Var& var, uint16_t& val);
void getCopyAsImpl(const Var& var, bool& val);
void getCopyAsImpl(const Var& var, std::string& val);
void getCopyAsImpl(const Var& var, VarList& val);
void getCopyAsImpl(const Var& var, VarMap& val);
void getCopyAsImpl(const Var& var, KeyedVar& val);
 
void getCheckedCopyAsImpl(const Var& var, std::monostate& val);
void getCheckedCopyAsImpl(const Var& var, int32_t& val);
void getCheckedCopyAsImpl(const Var& var, uint32_t& val);
void getCheckedCopyAsImpl(const Var& var, int64_t& val);
void getCheckedCopyAsImpl(const Var& var, uint64_t& val);
void getCheckedCopyAsImpl(const Var& var, float32_t& val);
void getCheckedCopyAsImpl(const Var& var, float64_t& val);
void getCheckedCopyAsImpl(const Var& var, Duration& val);
void getCheckedCopyAsImpl(const Var& var, TimeStamp& val);
void getCheckedCopyAsImpl(const Var& var, uint8_t& val);
void getCheckedCopyAsImpl(const Var& var, int16_t& val);
void getCheckedCopyAsImpl(const Var& var, uint16_t& val);
void getCheckedCopyAsImpl(const Var& var, bool& val);
void getCheckedCopyAsImpl(const Var& var, std::string& val);
void getCheckedCopyAsImpl(const Var& var, VarList& val);
void getCheckedCopyAsImpl(const Var& var, VarMap& val);
void getCheckedCopyAsImpl(const Var& var, KeyedVar& val);
 
}  // namespace impl
 
//--------------------------------------------------------------------------------------------------------------
// Free functions
//--------------------------------------------------------------------------------------------------------------
 
template <typename To, bool checkedConversion>
inline To getCopyAs(const Var& var)
{
  if constexpr (isVarTypeMemberV<To>)
  {
    // don't transform if already the same type
    if (var.holds<To>())
    {
      return var.get<To>();
    }
 
    To value {};
    if constexpr (checkedConversion)
    {
      impl::getCheckedCopyAsImpl(var, value);
    }
    else
    {
      impl::getCopyAsImpl(var, value);
    }
    return value;
  }
  else
  {
    To value {};
    ::sen::VariantTraits<To>::variantToValue(var, value);
    return value;
  }
}
 
inline const Var& findElement(const VarMap& map, const std::string& key, const std::string& errorMessage)
{
  if (auto itr = map.find(key); itr != map.end())
  {
    return itr->second;
  }
 
  ::sen::throwRuntimeError(errorMessage);
  SEN_UNREACHABLE();
}
 
}  // namespace sen
 
#endif  // SEN_CORE_META_VAR_H