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 <set>
 
namespace simdjson {
namespace internal {
 
enum class layout_mode {
  INLINE,              // 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
};
 
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<std::string> common_keys{};
 
  layout_mode recommended_layout = layout_mode::EXPANDED;
 
  std::vector<element_metrics> children{};
};
 
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);
 
private:
  const fractured_json_options* current_opts_ = nullptr;
 
  element_metrics analyze_element(const dom::element& elem, size_t depth);
 
  element_metrics analyze_scalar(const dom::element& elem);
 
  element_metrics analyze_array(const dom::array& arr, size_t depth);
 
  element_metrics analyze_object(const dom::object& obj, size_t depth);
 
  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,
                               std::vector<std::string>& common_keys) const;
 
  double compute_object_similarity(const dom::object& a,
                                   const dom::object& b) const;
 
  layout_mode decide_layout(const element_metrics& metrics,
                            size_t depth,
                            size_t available_width) const;
};
 
} // namespace internal
} // namespace simdjson
 
#endif // SIMDJSON_INTERNAL_JSON_STRUCTURE_ANALYZER_H