data.hpp

Go to the documentation of this file.

// (C) Copyright 2025, SECO Mind Srl
//
// SPDX-License-Identifier: Apache-2.0
 
#ifndef ASTARTE_DEVICE_SDK_DATA_H
#define ASTARTE_DEVICE_SDK_DATA_H

 
#include <chrono>
#include <cstdint>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <type_traits>
#include <variant>
#include <vector>
 
#include "astarte_device_sdk/formatter.hpp"
#include "astarte_device_sdk/type.hpp"
 
namespace astarte::device {

template <typename T>
concept DataAllowedType = requires {
  requires std::is_same_v<T, int32_t> || std::is_same_v<T, int64_t> || std::is_same_v<T, double> ||
               std::is_same_v<T, bool> || std::is_same_v<T, std::string> ||
               std::is_same_v<T, std::string_view> || std::is_same_v<T, std::vector<uint8_t>> ||
               std::is_same_v<T, std::chrono::system_clock::time_point> ||
               std::is_same_v<T, std::vector<int32_t>> || std::is_same_v<T, std::vector<int64_t>> ||
               std::is_same_v<T, std::vector<double>> || std::is_same_v<T, std::vector<bool>> ||
               std::is_same_v<T, std::vector<std::string>> ||
               std::is_same_v<T, std::vector<std::vector<uint8_t>>> ||
               std::is_same_v<T, std::vector<std::chrono::system_clock::time_point>>;
};

class Data {
 public:
  template <DataAllowedType T>
  explicit Data(const T& value) {
    if constexpr (std::is_same_v<T, std::string_view>) {
      data_ = std::string(value);
    } else {
      data_ = value;
    }
  }

  template <DataAllowedType T>
  [[nodiscard]] auto into() const
      -> std::conditional_t<std::is_same_v<T, std::string_view>, std::string_view, const T&> {
    if constexpr (std::is_same_v<T, std::string_view>) {
      return std::string_view(std::get<std::string>(data_));
    } else {
      return std::get<T>(data_);
    }
  }

  template <DataAllowedType T>
  [[nodiscard]] auto try_into() const -> std::optional<T> {
    if constexpr (std::is_same_v<T, std::string_view>) {
      if (std::holds_alternative<std::string>(data_)) {
        return std::string_view(std::get<std::string>(data_));
      }
    } else {
      if (std::holds_alternative<T>(data_)) {
        return std::get<T>(data_);
      }
    }
 
    return std::nullopt;
  }

  [[nodiscard]] auto get_type() const -> Type;

  [[nodiscard]] auto get_raw_data() const
      -> const std::variant<int32_t, int64_t, double, bool, std::string, std::vector<uint8_t>,
                            std::chrono::system_clock::time_point, std::vector<int32_t>,
                            std::vector<int64_t>, std::vector<double>, std::vector<bool>,
                            std::vector<std::string>, std::vector<std::vector<uint8_t>>,
                            std::vector<std::chrono::system_clock::time_point>>&;
  [[nodiscard]] auto operator==(const Data& other) const -> bool;

  [[nodiscard]] auto operator!=(const Data& other) const -> bool;
 
 private:
  std::variant<int32_t, int64_t, double, bool, std::string, std::vector<uint8_t>,
               std::chrono::system_clock::time_point, std::vector<int32_t>, std::vector<int64_t>,
               std::vector<double>, std::vector<bool>, std::vector<std::string>,
               std::vector<std::vector<uint8_t>>,
               std::vector<std::chrono::system_clock::time_point>>
      data_;
};
 
}  // namespace astarte::device

template <>
struct astarte_fmt::formatter<astarte::device::Data> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) const {
    return ctx.begin();
  }

  template <typename FormatContext>
  // NOLINTNEXTLINE(readability-function-size)
  auto format(const astarte::device::Data& data, FormatContext& ctx) const {
    auto out = ctx.out();
 
    if (std::holds_alternative<int32_t>(data.get_raw_data())) {
      out = astarte_fmt::format_to(out, "{}", std::get<int32_t>(data.get_raw_data()));
    } else if (std::holds_alternative<int64_t>(data.get_raw_data())) {
      out = astarte_fmt::format_to(out, "{}", std::get<int64_t>(data.get_raw_data()));
    } else if (std::holds_alternative<double>(data.get_raw_data())) {
      out = astarte_fmt::format_to(out, "{}", std::get<double>(data.get_raw_data()));
    } else if (std::holds_alternative<bool>(data.get_raw_data())) {
      const auto* bool_str = (std::get<bool>(data.get_raw_data()) ? "true" : "false");
      out = astarte_fmt::format_to(out, "{}", bool_str);
    } else if (std::holds_alternative<std::string>(data.get_raw_data())) {
      out = astarte_fmt::format_to(out, R"("{}")", std::get<std::string>(data.get_raw_data()));
    } else if (std::holds_alternative<std::vector<uint8_t>>(data.get_raw_data())) {
      astarte::device::utils::format_base64(out,
                                            std::get<std::vector<uint8_t>>(data.get_raw_data()));
    } else if (std::holds_alternative<std::chrono::system_clock::time_point>(data.get_raw_data())) {
      astarte::device::utils::format_timestamp(
          out, std::get<std::chrono::system_clock::time_point>(data.get_raw_data()));
    } else if (std::holds_alternative<std::vector<int32_t>>(data.get_raw_data())) {
      astarte::device::utils::format_vector(out,
                                            std::get<std::vector<int32_t>>(data.get_raw_data()));
    } else if (std::holds_alternative<std::vector<int64_t>>(data.get_raw_data())) {
      astarte::device::utils::format_vector(out,
                                            std::get<std::vector<int64_t>>(data.get_raw_data()));
    } else if (std::holds_alternative<std::vector<double>>(data.get_raw_data())) {
      astarte::device::utils::format_vector(out,
                                            std::get<std::vector<double>>(data.get_raw_data()));
    } else if (std::holds_alternative<std::vector<bool>>(data.get_raw_data())) {
      astarte::device::utils::format_vector(out, std::get<std::vector<bool>>(data.get_raw_data()));
    } else if (std::holds_alternative<std::vector<std::string>>(data.get_raw_data())) {
      astarte::device::utils::format_vector(
          out, std::get<std::vector<std::string>>(data.get_raw_data()));
    } else if (std::holds_alternative<std::vector<std::vector<uint8_t>>>(data.get_raw_data())) {
      astarte::device::utils::format_vector(
          out, std::get<std::vector<std::vector<uint8_t>>>(data.get_raw_data()));
    } else if (std::holds_alternative<std::vector<std::chrono::system_clock::time_point>>(
                   data.get_raw_data())) {
      astarte::device::utils::format_vector(
          out, std::get<std::vector<std::chrono::system_clock::time_point>>(data.get_raw_data()));
    }
 
    return out;
  }
};

inline auto operator<<(std::ostream& out, const astarte::device::Data& data) -> std::ostream& {
  out << astarte_fmt::format("{}", data);
  return out;
}
 
#endif  // ASTARTE_DEVICE_SDK_DATA_H