serialization.h

#ifndef SIMDJSON_SERIALIZATION_H
#define SIMDJSON_SERIALIZATION_H
 
#include "simdjson/dom/base.h"
#include "simdjson/dom/element.h"
#include "simdjson/dom/object.h"
 
#include <vector>
 
namespace simdjson {
 
namespace internal {
 
template<class formatter>
class base_formatter {
public:
  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;
 
  simdjson_inline void one_char(char c);
 
  simdjson_inline void call_print_newline() {
      static_cast<formatter*>(this)->print_newline();
  }
 
  simdjson_inline void call_print_indents(size_t depth) {
      static_cast<formatter*>(this)->print_indents(depth);
  }
 
  simdjson_inline void call_print_space() {
      static_cast<formatter*>(this)->print_space();
  }
 
protected:
  // implementation details (subject to change)
  std::vector<char> buffer{}; // not ideal!
};
 
 
class mini_formatter : public base_formatter<mini_formatter> {
public:
  simdjson_inline void print_newline();
 
  simdjson_inline void print_indents(size_t depth);
 
  simdjson_inline void print_space();
};
 
class pretty_formatter : public base_formatter<pretty_formatter> {
public:
  simdjson_inline void print_newline();
 
  simdjson_inline void print_indents(size_t depth);
 
  simdjson_inline void print_space();
 
protected:
  int indent_step = 4;
};
 
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{};
};
 
} // internal
 
namespace dom {
 
inline std::ostream& operator<<(std::ostream& out, simdjson::dom::element value);
#if SIMDJSON_EXCEPTIONS
inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::dom::element> x);
#endif
inline std::ostream& operator<<(std::ostream& out, simdjson::dom::array value);
#if SIMDJSON_EXCEPTIONS
inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::dom::array> x);
#endif
inline std::ostream& operator<<(std::ostream& out, simdjson::dom::object value);
#if SIMDJSON_EXCEPTIONS
inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::dom::object> x);
#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
 
template <class T>
std::string prettify(T x)  {
    simdjson::internal::string_builder<simdjson::internal::pretty_formatter> 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 prettify(simdjson_result<T> x) {
    if (x.error()) { throw simdjson_error(x.error()); }
    return to_string(x.value());
}
#endif
 
} // namespace simdjson
 
 
#endif