draconisplusplus/include/rfl/parsing/IsWriter.hpp

#ifndef RFL_PARSING_ISWRITER_HPP_
#define RFL_PARSING_ISWRITER_HPP_

#include <concepts>
#include <string>
#include <string_view>

#include "../Result.hpp"

namespace rfl {
  namespace parsing {

    template <class W, class T>
    concept IsWriter = requires(W w,
                                T t,
                                std::string_view name,
                                std::string basic_value,
                                typename W::OutputArrayType arr,
                                typename W::OutputObjectType obj,
                                typename W::OutputVarType var,
                                size_t size) {
      /// Sets an empty array as the root element of the document.
      /// Some serialization formats require you to pass the expected size in
      /// advance. If you are not working with such a format, you can ignore the
      /// parameter `size`. Returns the new array for further modification.
      { w.array_as_root(size) } -> std::same_as<typename W::OutputArrayType>;

      /// Sets an empty object as the root element of the document.
      /// Some serialization formats require you to pass the expected size in
      /// advance. If you are not working with such a format, you can ignore the
      /// parameter `size`.
      /// Returns the new object for further modification.
      { w.object_as_root(size) } -> std::same_as<typename W::OutputObjectType>;

      /// Sets a null as the root element of the document. Returns OutputVarType
      /// containing the null value.
      { w.null_as_root() } -> std::same_as<typename W::OutputVarType>;

      /// Sets a basic value (bool, numeric, string) as the root element of the
      /// document. Returns an OutputVarType containing the new value.
      {
        w.value_as_root(basic_value)
      } -> std::same_as<typename W::OutputVarType>;

      /// Adds an empty array to an existing array. Returns the new
      /// array for further modification.
      {
        w.add_array_to_array(size, &arr)
      } -> std::same_as<typename W::OutputArrayType>;

      /// Adds an empty object to an existing array. Returns the new
      /// object for further modification.
      {
        w.add_object_to_array(size, &arr)
      } -> std::same_as<typename W::OutputObjectType>;

      /// Adds an empty array to an existing object. The key or name of the
      /// field is signified by `name`. Returns the new array for further
      /// modification.
      {
        w.add_array_to_object(name, size, &obj)
      } -> std::same_as<typename W::OutputArrayType>;

      /// Adds an empty object to an existing object. The key or name of the
      /// field is signified by `name`. Returns the new object for further
      /// modification.
      {
        w.add_object_to_object(name, size, &obj)
      } -> std::same_as<typename W::OutputObjectType>;

      /// Adds a basic value (bool, numeric, string) to an array. Returns an
      /// OutputVarType containing the new value.
      {
        w.add_value_to_array(basic_value, &arr)
      } -> std::same_as<typename W::OutputVarType>;

      /// Adds a basic value (bool, numeric, string) to an existing object. The
      /// key or name of the field is signified by `name`. Returns an
      /// OutputVarType containing the new value.
      {
        w.add_value_to_object(name, basic_value, &obj)
      } -> std::same_as<typename W::OutputVarType>;

      /// Adds a null value to an array. Returns an
      /// OutputVarType containing the null value.
      { w.add_null_to_array(&arr) } -> std::same_as<typename W::OutputVarType>;

      /// Adds a null value to an existing object. The key
      /// or name of the field is signified by `name`. Returns an
      /// OutputVarType containing the null value.
      {
        w.add_null_to_object(name, &obj)
      } -> std::same_as<typename W::OutputVarType>;

      /// Signifies to the writer that we do not want to add any further
      /// elements to this array. Some serialization formats require this. If
      /// you are working with a serialization format that doesn't, just leave
      /// the function empty.
      { w.end_array(&arr) } -> std::same_as<void>;

      /// Signifies to the writer that we do not want to add any further
      /// elements to this object. Some serialization formats require this. If
      /// you are working with a serialization format that doesn't, just leave
      /// the function empty.
      { w.end_object(&obj) } -> std::same_as<void>;
    };

  } // namespace parsing
} // namespace rfl

#endif