msg.hpp

Go to the documentation of this file.

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

 
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
 
#include "astarte_device_sdk/formatter.hpp"
#include "astarte_device_sdk/individual.hpp"
#include "astarte_device_sdk/object.hpp"
#include "astarte_device_sdk/property.hpp"
 
namespace astarte::device {

class Message {
 public:
  template <typename T>
  Message(std::string_view interface, std::string_view path, T data)
      : interface_(interface), path_(path), data_(std::move(data)) {}

  [[nodiscard]] auto get_interface() const -> const std::string&;

  [[nodiscard]] auto get_path() const -> const std::string&;

  [[nodiscard]] auto is_datastream() const -> bool;

  [[nodiscard]] auto is_individual() const -> bool;

  template <typename T>
  [[nodiscard]] auto into() const -> const T& {
    return std::get<T>(data_);
  }

  template <typename T>
  [[nodiscard]] auto try_into() const -> std::optional<T> {
    if (std::holds_alternative<T>(data_)) {
      return std::get<T>(data_);
    }
 
    return std::nullopt;
  }

  [[nodiscard]] auto get_raw_data() const
      -> const std::variant<DatastreamIndividual, DatastreamObject, PropertyIndividual>&;

  [[nodiscard]] auto operator==(const Message& other) const -> bool;

  [[nodiscard]] auto operator!=(const Message& other) const -> bool;
 
 private:
  std::string interface_;
  std::string path_;
  std::variant<DatastreamIndividual, DatastreamObject, PropertyIndividual> data_;
};
 
}  // namespace astarte::device

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

  template <typename FormatContext>
  auto format(const astarte::device::Message& msg, FormatContext& ctx) const {
    auto out = ctx.out();
 
    out = astarte_fmt::format_to(out, "{{interface: {}, path: {}", msg.get_interface(),
                                 msg.get_path());
 
    // check if the payload is an unset property, which is the only "empty" case
    bool is_unset_prop = false;
    const auto* prop = std::get_if<astarte::device::PropertyIndividual>(&msg.get_raw_data());
    if (prop && !prop->get_value().has_value()) {
      is_unset_prop = true;
    }
 
    if (!is_unset_prop) {
      out = astarte_fmt::format_to(out, ", value: ");
      std::visit([&out](const auto& arg) { out = astarte_fmt::format_to(out, "{}", arg); },
                 msg.get_raw_data());
    }
 
    return astarte_fmt::format_to(out, "}}");
  }
};

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