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"
 
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 chars(const char *begin, const char *end);
 
  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)
  struct vector_with_small_buffer {
    vector_with_small_buffer() = default;
    ~vector_with_small_buffer() { free_buffer(); }
 
    vector_with_small_buffer(const vector_with_small_buffer &) = delete;
    vector_with_small_buffer &
    operator=(const vector_with_small_buffer &) = delete;
 
    void clear() {
      size = 0;
      capacity = StaticCapacity;
      free_buffer();
      buffer = array;
    }
 
    simdjson_inline void push_back(char c) {
      if (capacity < size + 1)
        grow(capacity * 2);
      buffer[size++] = c;
    }
 
    simdjson_inline void append(const char *begin, const char *end) {
      const size_t new_size = size + (end - begin);
      if (capacity < new_size)
        // std::max(new_size, capacity * 2); is broken in tests on Windows
        grow(new_size < capacity * 2 ? capacity * 2 : new_size);
      std::copy(begin, end, buffer + size);
      size = new_size;
    }
 
    std::string_view str() const { return std::string_view(buffer, size); }
 
  private:
    void free_buffer() {
      if (buffer != array)
        delete[] buffer;
    }
    void grow(size_t new_capacity) {
      auto new_buffer = new char[new_capacity];
      std::copy(buffer, buffer + size, new_buffer);
      free_buffer();
      buffer = new_buffer;
      capacity = new_capacity;
    }
 
    static const size_t StaticCapacity = 64;
    char array[StaticCapacity];
    char *buffer = array;
    size_t size = 0;
    size_t capacity = StaticCapacity;
  } buffer{};
};
 
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{};
};
 
} // namespace 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