json_structure_analyzer.h

#ifndef SIMDJSON_INTERNAL_JSON_STRUCTURE_ANALYZER_H
#define SIMDJSON_INTERNAL_JSON_STRUCTURE_ANALYZER_H
 
#include "simdjson/dom/base.h"
#include "simdjson/dom/element.h"
#include "simdjson/dom/array.h"
#include "simdjson/dom/object.h"
#include "simdjson/dom/fractured_json.h"
#include "simdjson/internal/tape_type.h"
 
#include <vector>
#include <string>
#include <string_view>
#include <utility>
 
namespace simdjson {
namespace internal {
 
enum class layout_mode {
  single_line,         // Single line: [1, 2, 3] or {"a": 1}
  compact_multiline,   // Multiple items per line with breaks
  table,               // Tabular format for arrays of similar objects
  expanded             // Traditional multi-line with indentation
};
 
enum class table_column_type {
  unknown,
  simple,   // string, bool, or null
  number,
  array,
  object,
  mixed     // rows disagree on kind
};
 
struct table_column {
  std::string key{};
  size_t key_width = 0;
  table_column_type type = table_column_type::unknown;
  size_t width = 0;
  size_t plain_width = 0;
  std::vector<table_column> children{};
};
 
inline bool table_row_is_nested(const std::vector<table_column>& columns) {
  for (const table_column& col : columns) {
    if (col.type == table_column_type::object || col.type == table_column_type::array) {
      return true;
    }
  }
  return false;
}
 
struct element_metrics {
  size_t complexity = 0;
 
  size_t estimated_inline_len = 0;
 
  size_t child_count = 0;
 
  bool can_inline = false;
 
  bool is_uniform_array = false;
 
  std::vector<table_column> table_columns{};
  size_t table_row_width = 0;
  size_t table_row_width_full = 0;
 
  std::vector<element_metrics> children{};
 
  table_column_type scalar_column_type = table_column_type::unknown;
};
 
inline const element_metrics& child_metrics_at(const std::vector<element_metrics>& children, size_t idx) {
  static const element_metrics empty{};
  return idx < children.size() ? children[idx] : empty;
}
 
inline const element_metrics& child_metrics_at(const element_metrics* ptr) {
  static const element_metrics empty{};
  return ptr ? *ptr : empty;
}
 
class structure_analyzer {
public:
  structure_analyzer() : current_opts_(nullptr) {}
 
  structure_analyzer(const structure_analyzer&) = delete;
 
  structure_analyzer& operator=(const structure_analyzer&) = delete;
 
  structure_analyzer(structure_analyzer&&) = default;
 
  structure_analyzer& operator=(structure_analyzer&&) = default;
 
  element_metrics analyze(const dom::element& elem,
                          const fractured_json_options& opts);
 
  void clear();
 
  element_metrics analyze_array(const dom::array& arr,
                                const fractured_json_options& opts);
 
  element_metrics analyze_object(const dom::object& obj,
                                 const fractured_json_options& opts);
 
  static layout_mode decide_layout(const element_metrics& metrics,
                                    size_t depth,
                                    const fractured_json_options& opts,
                                    bool has_trailing_comma = false);
 
private:
  const fractured_json_options* current_opts_ = nullptr;
 
  element_metrics analyze_element(const dom::element& elem, size_t depth) const;
 
  element_metrics analyze_scalar(const dom::element& elem) const;
 
  element_metrics analyze_array(const dom::array& arr, size_t depth) const;
 
  element_metrics analyze_object(const dom::object& obj, size_t depth) const;
 
  size_t estimate_string_length(std::string_view s) const;
 
  size_t estimate_number_length(double d) const;
  size_t estimate_number_length(int64_t i) const;
  size_t estimate_number_length(uint64_t u) const;
 
  bool check_array_uniformity(const dom::array& arr, element_metrics& metrics, size_t depth) const;
 
  static table_column_type classify_table_value(dom::element_type type);
 
  static void classify_and_measure(const std::vector<std::pair<dom::element, const element_metrics*>>& values,
                                    table_column_type& common, size_t& max_width);
 
  void build_table_columns(const std::vector<std::pair<dom::element, const element_metrics*>>& values,
                            std::vector<table_column>& out_columns) const;
 
  size_t compute_columns_width(const std::vector<table_column>& columns) const;
 
  static size_t column_height(const table_column& column);
 
  static bool flatten_deepest_columns(std::vector<table_column>& columns);
 
  void recompute_column_widths(std::vector<table_column>& columns) const;
};
 
} // namespace internal
} // namespace simdjson
 
#endif // SIMDJSON_INTERNAL_JSON_STRUCTURE_ANALYZER_H