larra/library/include/larra/stream.hpp

#pragma once
#include <libxml++/libxml++.h>

#include <larra/jid.hpp>

namespace larra::xmpp {

namespace impl {

template <bool JidFrom, bool JidTo>
struct BasicStream {
  static constexpr bool kJidFrom = JidFrom;
  static constexpr bool kJidTo = JidTo;
  using FromType = std::optional<std::conditional_t<JidFrom, BareJid, std::string>>;
  using ToType = std::optional<std::conditional_t<JidTo, BareJid, std::string>>;
  static inline const std::string kDefaultNamespace = JidFrom || JidTo ? "jabber:client" : "jabber:server";
  static constexpr auto kRemoveEnd = true;
  static constexpr auto kAddXmlDecl = true;
  static inline const std::string kDefaultPrefix = "";
  static inline const std::string kDefaultName = "stream:stream";
  FromType from{};
  ToType to{};
  std::optional<std::string> id;
  std::optional<std::string> version;
  std::optional<std::string> xmlLang;

  template <typename Self>
  [[nodiscard]] constexpr auto From(this Self&& self, FromType value) -> BasicStream {
    return utils::FieldSetHelper::With<"from", BasicStream>(std::forward<Self>(self), std::move(value));
  }

  template <typename Self>
  [[nodiscard]] constexpr auto To(this Self&& self, ToType value) -> BasicStream {
    return utils::FieldSetHelper::With<"to", BasicStream>(std::forward<Self>(self), std::move(value));
  }

  template <typename Self>
  [[nodiscard]] constexpr auto Id(this Self&& self, std::optional<std::string> value) -> BasicStream {
    return utils::FieldSetHelper::With<"id", BasicStream>(std::forward<Self>(self), std::move(value));
  }

  template <typename Self>
  [[nodiscard]] constexpr auto Version(this Self&& self, std::optional<std::string> value) -> BasicStream {
    return utils::FieldSetHelper::With<"version", BasicStream>(std::forward<Self>(self), std::move(value));
  }

  template <typename Self>
  [[nodiscard]] constexpr auto XmlLang(this Self&& self, std::optional<std::string> value)  // NOLINT(cppcoreguidelines-missing-std-forward)
      -> BasicStream {
    return utils::FieldSetHelper::With<"xmlLang", BasicStream>(std::forward_like<Self>(self), std::move(value));
  }

  auto SerializeStream(xmlpp::Element* node) const -> void;

  friend auto operator<<(xmlpp::Element* node, const BasicStream& stream) -> xmlpp::Element* {
    stream.SerializeStream(node);
    return node;
  }
  friend auto ToString(const BasicStream<JidFrom, JidTo>&) -> std::string;
  [[nodiscard]] static auto Parse(const xmlpp::Element*) -> BasicStream;
};

}  // namespace impl

using UserStream = impl::BasicStream<true, false>;

using ServerStream = impl::BasicStream<false, false>;
using ServerToUserStream = impl::BasicStream<false, true>;

}  // namespace larra::xmpp