serialization.h

#ifndef SIMDJSON_SERIALIZATION_H
#define SIMDJSON_SERIALIZATION_H
 
#include "simdjson/common_defs.h"
#include "simdjson/dom/document.h"
#include "simdjson/error.h"
#include "simdjson/internal/dom_parser_implementation.h"
#include "simdjson/internal/tape_ref.h"
#include "simdjson/padded_string.h"
#include "simdjson/portability.h"
#include <vector>
 
namespace simdjson {
 
namespace internal {
 
class mini_formatter;
 
template <class formatter = mini_formatter>
class string_builder {
public:
  string_builder() = default;
  inline void append(simdjson::dom::element value);
  inline void append(simdjson::dom::array value);
  inline void append(simdjson::dom::object value);
  simdjson_inline void clear();
  simdjson_inline std::string_view str() const;
  simdjson_inline void append(simdjson::dom::key_value_pair value);
private:
  formatter format{};
};
 
class mini_formatter {
public:
  mini_formatter() = default;
  simdjson_inline void comma();
  simdjson_inline void start_array();
  simdjson_inline void end_array();
  simdjson_inline void start_object();
  simdjson_inline void end_object();
  simdjson_inline void true_atom();
  simdjson_inline void false_atom();
  simdjson_inline void null_atom();
  simdjson_inline void number(int64_t x);
  simdjson_inline void number(uint64_t x);
  simdjson_inline void number(double x);
  simdjson_inline void key(std::string_view unescaped);
  simdjson_inline void string(std::string_view unescaped);
  simdjson_inline void clear();
  simdjson_inline std::string_view str() const;
 
private:
  // implementation details (subject to change)
  simdjson_inline void one_char(char c);
  std::vector<char> buffer{}; // not ideal!
};
 
} // internal
 
namespace dom {
 
inline std::ostream& operator<<(std::ostream& out, simdjson::dom::element value) {
    simdjson::internal::string_builder<> sb;
    sb.append(value);
    return (out << sb.str());
}
#if SIMDJSON_EXCEPTIONS
inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::dom::element> x) {
    if (x.error()) { throw simdjson::simdjson_error(x.error()); }
    return (out << x.value());
}
#endif
inline std::ostream& operator<<(std::ostream& out, simdjson::dom::array value)  {
    simdjson::internal::string_builder<> sb;
    sb.append(value);
    return (out << sb.str());
}
#if SIMDJSON_EXCEPTIONS
inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::dom::array> x) {
    if (x.error()) { throw simdjson::simdjson_error(x.error()); }
    return (out << x.value());
}
#endif
inline std::ostream& operator<<(std::ostream& out, simdjson::dom::object value)   {
    simdjson::internal::string_builder<> sb;
    sb.append(value);
    return (out << sb.str());
}
#if SIMDJSON_EXCEPTIONS
inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::dom::object> x) {
    if (x.error()) { throw  simdjson::simdjson_error(x.error()); }
    return (out << x.value());
}
#endif
} // namespace dom
 
template <class T>
std::string to_string(T x)   {
    // in C++, to_string is standard: http://www.cplusplus.com/reference/string/to_string/
    // Currently minify and to_string are identical but in the future, they may
    // differ.
    simdjson::internal::string_builder<> sb;
    sb.append(x);
    std::string_view answer = sb.str();
    return std::string(answer.data(), answer.size());
}
#if SIMDJSON_EXCEPTIONS
template <class T>
std::string to_string(simdjson_result<T> x) {
    if (x.error()) { throw simdjson_error(x.error()); }
    return to_string(x.value());
}
#endif
 
template <class T>
std::string minify(T x)  {
  return to_string(x);
}
 
#if SIMDJSON_EXCEPTIONS
template <class T>
std::string minify(simdjson_result<T> x) {
    if (x.error()) { throw simdjson_error(x.error()); }
    return to_string(x.value());
}
#endif
 
 
} // namespace simdjson
 
 
#endif