object.hpp

Go to the documentation of this file.

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

 
#include <initializer_list>
#include <ostream>
#include <string>
#include <unordered_map>
 
#include "astarte_device_sdk/data.hpp"
#include "astarte_device_sdk/formatter.hpp"
 
namespace astarte::device {

class DatastreamObject {
 public:
  using MapType = std::unordered_map<std::string, Data>;
  using iterator = MapType::iterator;
  using const_iterator = MapType::const_iterator;
  using size_type = MapType::size_type;
  using value_type = MapType::value_type;

  DatastreamObject();

  DatastreamObject(std::initializer_list<value_type> init);

  auto at(const std::string& key) -> Data&;

  auto at(const std::string& key) const -> const Data&;

  auto begin() -> iterator;

  auto begin() const -> const_iterator;

  auto end() -> iterator;

  auto end() const -> const_iterator;

  auto size() const -> size_type;

  auto empty() const -> bool;

  void insert(const std::string& key, const Data& data);

  auto erase(const std::string& key) -> size_type;

  void clear();

  auto find(const std::string& key) -> iterator;

  auto find(const std::string& key) const -> const_iterator;

  auto get_raw_data() const -> const MapType&;

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

  [[nodiscard]] auto operator!=(const DatastreamObject& other) const -> bool;
 
 private:
  MapType data_;
};
 
}  // namespace astarte::device

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

  template <typename FormatContext>
  auto format(const astarte::device::DatastreamObject& data, FormatContext& ctx) const {
    auto out = ctx.out();
    out = astarte_fmt::format_to(out, "{{");
 
    bool first = true;
    for (const auto& pair : data.get_raw_data()) {
      if (!first) {
        out = astarte_fmt::format_to(out, ", ");
      }
      out = astarte_fmt::format_to(out, R"("{}": {})", pair.first, pair.second);
      first = false;
    }
 
    out = astarte_fmt::format_to(out, "}}");
    return out;
  }
};

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