operations.hpp

#pragma once
 
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
 
#include <userver/dump/fwd.hpp>
#include <userver/dump/meta.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace dump {
 
class Error final : public std::runtime_error {
 public:
  explicit Error(std::string message) : std::runtime_error(message) {}
};
 
class Writer {
 public:
  virtual ~Writer() = default;
 
  template <typename T>
  void Write(const T& data);
 
  virtual void Finish() = 0;
 
 protected:
  virtual void WriteRaw(std::string_view data) = 0;
 
  friend void WriteStringViewUnsafe(Writer& writer, std::string_view value);
};
 
class Reader {
 public:
  virtual ~Reader() = default;
 
  template <typename T>
  T Read();
 
  virtual void Finish() = 0;
 
 protected:
  virtual std::string_view ReadRaw(std::size_t max_size) = 0;
 
  friend std::string_view ReadUnsafeAtMost(Reader& reader, std::size_t size);
};
 
namespace impl {
 
template <typename T>
void CallWrite(Writer& writer, const T& data) {
  Write(writer, data);
}
 
template <typename T>
// NOLINTNEXTLINE(readability-const-return-type)
T CallRead(Reader& reader, To<T> to) {
  return Read(reader, to);
}
 
}  // namespace impl
 
template <typename T>
void Writer::Write(const T& data) {
  if constexpr (kIsWritable<T>) {
    impl::CallWrite(*this, data);
  } else if constexpr (std::is_aggregate_v<T>) {
    static_assert(
        !sizeof(T),
        "Serialization is not implemented for this type. You "
        "either forgot to specialize IsDumpedAggregate for your type "
        "(see <userver/dump/aggregates.hpp>)"
        "or you've got a non-standard data type and need to implement "
        "`void Write(dump::Writer& writer, const T& data);` and put it "
        "in the namespace of `T` or in `dump`.");
  } else {
    static_assert(
        !sizeof(T),
        "You either forgot to `#include <userver/dump/common_containers.hpp>`, "
        "or you've got a non-standard data type and need to implement "
        "`void Write(dump::Writer& writer, const T& data);` and put it "
        "in the namespace of `T` or in `dump`.");
  }
}
 
template <typename T>
// NOLINTNEXTLINE(readability-const-return-type)
T Reader::Read() {
  if constexpr (kIsReadable<T>) {
    return impl::CallRead(*this, To<T>{});
  } else if constexpr (std::is_aggregate_v<T>) {
    static_assert(
        !sizeof(T),
        "Serialization is not implemented for this type. You "
        "either forgot to specialize IsDumpedAggregate for your type"
        "(see <userver/dump/aggregates.hpp>) "
        "or you've got a non-standard data type and need to implement "
        "`T Read(dump::Reader& reader, dump::To<T>);` and put it "
        "in the namespace of `T` or in `dump`.");
  } else {
    static_assert(
        !sizeof(T),
        "You either forgot to `#include <userver/dump/common_containers.hpp>`, "
        "or you've got a non-standard data type and need to implement"
        "`T Read(dump::Reader& reader, dump::To<T>);` and put it "
        "in the namespace of `T` or in `dump`.");
    return T{};
  }
}
 
}  // namespace dump
 
USERVER_NAMESPACE_END