fractured_formatter.h

#ifndef SIMDJSON_INTERNAL_FRACTURED_FORMATTER_H
#define SIMDJSON_INTERNAL_FRACTURED_FORMATTER_H
 
#include "simdjson/dom/serialization.h"
#include "simdjson/dom/fractured_json.h"
#include "simdjson/internal/json_structure_analyzer.h"
 
namespace simdjson {
namespace internal {
 
class fractured_formatter : public base_formatter<fractured_formatter> {
public:
  explicit fractured_formatter(const fractured_json_options& opts = {});
 
  simdjson_inline void print_newline();
 
  simdjson_inline void print_indents(size_t depth);
 
  simdjson_inline void print_space();
 
  void set_layout_mode(layout_mode mode);
 
  layout_mode get_layout_mode() const;
 
  void track_line_length(size_t chars);
 
  bool should_break_line(size_t upcoming_length) const;
 
  const fractured_json_options& options() const;
 
private:
  fractured_json_options options_;
  layout_mode current_layout_ = layout_mode::expanded;
  size_t current_line_length_ = 0;
};
 
class scoped_single_line_mode {
public:
  explicit scoped_single_line_mode(fractured_formatter& format)
      : format_(format), prev_(format.get_layout_mode()) {
    format_.set_layout_mode(layout_mode::single_line);
  }
  ~scoped_single_line_mode() { format_.set_layout_mode(prev_); }
  scoped_single_line_mode(const scoped_single_line_mode&) = delete;
  scoped_single_line_mode& operator=(const scoped_single_line_mode&) = delete;
 
private:
  fractured_formatter& format_;
  layout_mode prev_;
};
 
class fractured_string_builder {
public:
  fractured_string_builder(const fractured_json_options& opts = {});
 
  void append(const dom::element& value);
 
  void append(const dom::array& value);
 
  void append(const dom::object& value);
 
  simdjson_inline void clear();
 
  simdjson_inline std::string_view str() const;
 
private:
  fractured_formatter format_;
  structure_analyzer analyzer_;
  fractured_json_options options_;
 
  void format_element(const dom::element& elem, const element_metrics& metrics, size_t depth,
                       bool has_trailing_comma = false);
 
  void format_array(const dom::array& arr, const element_metrics& metrics, size_t depth,
                     bool has_trailing_comma = false);
 
  void format_array_inline(const dom::array& arr, const element_metrics& metrics);
 
  void format_array_compact_multiline(const dom::array& arr, const element_metrics& metrics, size_t depth);
 
  void format_array_compact_multiline_aligned(const dom::array& arr, const element_metrics& metrics, size_t depth);
 
  void format_array_as_table(const dom::array& arr, const element_metrics& metrics, size_t depth);
 
  void format_table_object_row(const dom::object& obj, const element_metrics& row_metrics,
                                const std::vector<table_column>& columns, size_t depth);
 
  void format_table_array_row(const dom::array& arr, const element_metrics& row_metrics,
                               const std::vector<table_column>& columns, size_t depth);
 
  void format_table_row(const dom::element& elem, const element_metrics& row_metrics,
                        const std::vector<table_column>& columns, size_t depth);
 
  void format_table_scalar_row(const dom::element& elem, const element_metrics& row_metrics,
                                size_t width, size_t depth, table_column_type column_type);
 
  void format_table_row_columns(const std::vector<table_column>& columns,
                                 const std::vector<bool>& found,
                                 const std::vector<dom::element>& values,
                                 const std::vector<const element_metrics*>& value_metrics,
                                 size_t depth);
 
  void format_table_leaf_value(const dom::element& elem, const element_metrics& vm, size_t width,
                                table_column_type column_type, bool needs_comma,
                                bool add_comma_space, size_t depth);
 
  bool comma_goes_before_padding(table_column_type column_type) const;
 
  void format_array_expanded(const dom::array& arr, const element_metrics& metrics, size_t depth);
 
  void format_object(const dom::object& obj, const element_metrics& metrics, size_t depth,
                      bool has_trailing_comma = false);
 
  void format_object_inline(const dom::object& obj, const element_metrics& metrics);
 
  void format_object_expanded(const dom::object& obj, const element_metrics& metrics, size_t depth);
 
  void format_scalar(const dom::element& elem);
 
  bool bracket_padding_for(const element_metrics& metrics) const;
};
 
} // namespace internal
} // namespace simdjson
 
#endif // SIMDJSON_INTERNAL_FRACTURED_FORMATTER_H