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 set_depth(size_t depth);
 
  size_t get_depth() const;
 
  void track_line_length(size_t chars);
 
  void reset_line_length();
 
  size_t get_line_length() const;
 
  bool should_break_line(size_t upcoming_length) const;
 
  const fractured_json_options& options() const;
 
  // Table formatting support
  void begin_table_row();
 
  void end_table_row();
 
  void set_column_widths(const std::vector<size_t>& widths);
 
  size_t get_column_index() const;
 
  void next_column();
 
  void align_to_column_width(size_t actual_width);
 
private:
  fractured_json_options options_;
  layout_mode current_layout_ = layout_mode::EXPANDED;
  size_t current_depth_ = 0;
  size_t current_line_length_ = 0;
 
  // Table state
  bool in_table_mode_ = false;
  std::vector<size_t> column_widths_;
  size_t current_column_ = 0;
};
 
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);
 
  void format_array(const dom::array& arr, const element_metrics& metrics, size_t depth);
 
  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_as_table(const dom::array& arr, const element_metrics& metrics, size_t depth);
 
  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);
 
  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);
 
  std::vector<size_t> calculate_column_widths(const dom::array& arr,
                                               const std::vector<std::string>& columns) const;
 
  size_t measure_value_length(const dom::element& elem) const;
};
 
} // namespace internal
} // namespace simdjson
 
#endif // SIMDJSON_INTERNAL_FRACTURED_FORMATTER_H