object.h

#ifndef SIMDJSON_GENERIC_ONDEMAND_OBJECT_H
 
#ifndef SIMDJSON_CONDITIONAL_INCLUDE
#define SIMDJSON_GENERIC_ONDEMAND_OBJECT_H
#include "simdjson/generic/ondemand/base.h"
#include "simdjson/generic/implementation_simdjson_result_base.h"
#include "simdjson/generic/ondemand/value_iterator.h"
#include "simdjson/generic/ondemand/key_selector.h"
#include <vector>
#if SIMDJSON_STATIC_REFLECTION && SIMDJSON_SUPPORTS_CONCEPTS
#include "simdjson/generic/ondemand/json_string_builder.h"  // for constevalutil::fixed_string
#endif
#endif // SIMDJSON_CONDITIONAL_INCLUDE
 
namespace simdjson {
namespace SIMDJSON_IMPLEMENTATION {
namespace ondemand {
 
#if SIMDJSON_SUPPORTS_CONCEPTS
struct [[nodiscard]] for_each_result {
  error_code error{SUCCESS};
  std::size_t matched_count{0};
  constexpr operator error_code() const noexcept { return error; }
};
 
namespace key_selector_for_each_detail {
template <typename H>
concept field_handler =
    std::is_invocable_v<std::remove_reference_t<H>&, value> ||
    ::simdjson::deserializable<std::remove_cvref_t<H>, value>;
 
template <typename H>
inline constexpr bool nothrow_field_handler_v =
    std::is_invocable_v<std::remove_reference_t<H>&, value>
        ? std::is_nothrow_invocable_v<std::remove_reference_t<H>&, value>
        : ::simdjson::nothrow_deserializable<std::remove_cvref_t<H>, value>;
 
template <typename... Handlers>
inline constexpr bool nothrow_field_handlers_v =
    (nothrow_field_handler_v<Handlers> && ...);
} // namespace key_selector_for_each_detail
#endif
 
struct object_position {
  simdjson_inline object_position() noexcept = default;
 
private:
  token_position position{};
  depth_t depth{};
 
  simdjson_inline object_position(token_position position_, depth_t depth_) noexcept
    : position(position_), depth(depth_) {}
 
  friend class object;
};
 
class object {
public:
  simdjson_inline object() noexcept = default;
 
  simdjson_inline simdjson_result<object_iterator> begin() noexcept;
  simdjson_inline simdjson_result<object_iterator> end() noexcept;
  simdjson_inline simdjson_result<value> find_field(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<value> find_field(std::string_view key) && noexcept;
 
  simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) && noexcept;
  simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;
  simdjson_inline simdjson_result<value> operator[](std::string_view key) && noexcept;
 
#if SIMDJSON_SUPPORTS_CONCEPTS
  template <typename Selector, typename Func>
    requires key_selector_type<Selector> &&
             std::is_invocable_v<Func&, std::size_t, value>
  simdjson_inline for_each_result for_each(Func&& on_match)
      noexcept(std::is_nothrow_invocable_v<Func&, std::size_t, value>);
 
  template <typename Selector, typename... Handlers>
    requires key_selector_type<Selector> &&
             (sizeof...(Handlers) == Selector::size()) &&
             (key_selector_for_each_detail::field_handler<Handlers> && ...)
  simdjson_inline for_each_result for_each(Handlers&&... on_match)
      noexcept(key_selector_for_each_detail::nothrow_field_handlers_v<Handlers...>);
 
  template <constevalutil::fixed_string... Keys, typename... Handlers>
    requires (sizeof...(Handlers) == sizeof...(Keys)) &&
             (sizeof...(Keys) >= 1) && (sizeof...(Keys) <= 255) &&
             (key_selector_for_each_detail::field_handler<Handlers> && ...)
  simdjson_inline for_each_result for_each(Handlers&&... on_match)
      noexcept(key_selector_for_each_detail::nothrow_field_handlers_v<Handlers...>);
#endif
 
  inline simdjson_result<value> at_pointer(std::string_view json_pointer) noexcept;
 
  inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
#if SIMDJSON_SUPPORTS_CONCEPTS
  template <typename Func>
    requires std::invocable<Func, value>
#else
  template <typename Func>
#endif
  inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
  inline simdjson_result<bool> reset() & noexcept;
  simdjson_inline object_position get_current_position() const noexcept;
  simdjson_inline error_code revert_position(object_position position) noexcept;
  inline simdjson_result<bool> is_empty() & noexcept;
  simdjson_inline simdjson_result<size_t> count_fields() & noexcept;
  simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
 
#if SIMDJSON_SUPPORTS_CONCEPTS
  template <typename T>
  simdjson_warn_unused simdjson_inline error_code get(T &out)
     noexcept(nothrow_gettable<T, object>) {
    static_assert(custom_deserializable<T, object>);
    return deserialize(*this, out);
  }
  template <typename T>
  simdjson_inline simdjson_result<T> get()
    noexcept(nothrow_gettable<T, object>)
  {
    static_assert(std::is_default_constructible<T>::value, "The specified type is not default constructible.");
    T out{};
    SIMDJSON_TRY(get<T>(out));
    return out;
  }
 
#if SIMDJSON_STATIC_REFLECTION
  template<constevalutil::fixed_string... FieldNames, typename T>
    requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))
  simdjson_warn_unused simdjson_inline error_code extract_into(T& out) & noexcept;
#endif // SIMDJSON_STATIC_REFLECTION
#endif // SIMDJSON_SUPPORTS_CONCEPTS
protected:
  simdjson_warn_unused simdjson_inline error_code consume() noexcept;
  static simdjson_inline simdjson_result<object> start(value_iterator &iter) noexcept;
  static simdjson_inline simdjson_result<object> start_root(value_iterator &iter) noexcept;
  static simdjson_inline simdjson_result<object> started(value_iterator &iter) noexcept;
  static simdjson_inline object resume(const value_iterator &iter) noexcept;
  simdjson_inline object(const value_iterator &iter) noexcept;
 
  simdjson_warn_unused simdjson_inline error_code find_field_raw(const std::string_view key) noexcept;
 
  value_iterator iter{};
#if SIMDJSON_DEVELOPMENT_CHECKS
  bool locked{false};
  simdjson_inline void set_locked(bool _locked) noexcept;
#endif
 
  friend class value;
  friend class document;
  friend struct simdjson_result<object>;
#if SIMDJSON_DEVELOPMENT_CHECKS
  friend class object_iterator;
  friend struct simdjson_result<object_iterator>;
#endif
};
 
} // namespace ondemand
} // namespace SIMDJSON_IMPLEMENTATION
} // namespace simdjson
 
namespace simdjson {
 
template<>
struct simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object> : public SIMDJSON_IMPLEMENTATION::implementation_simdjson_result_base<SIMDJSON_IMPLEMENTATION::ondemand::object> {
public:
  simdjson_inline simdjson_result(SIMDJSON_IMPLEMENTATION::ondemand::object &&value) noexcept; 
  simdjson_inline simdjson_result(error_code error) noexcept; 
  simdjson_inline simdjson_result() noexcept = default;
 
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object_iterator> begin() noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object_iterator> end() noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field(std::string_view key) && noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) && noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) && noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
#if SIMDJSON_SUPPORTS_CONCEPTS
  template <typename Func>
    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
#else
  template <typename Func>
#endif
  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
  inline simdjson_result<bool> reset() noexcept;
  inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object_position> get_current_position() noexcept;
  inline error_code revert_position(SIMDJSON_IMPLEMENTATION::ondemand::object_position position) noexcept;
  inline simdjson_result<bool> is_empty() noexcept;
  inline simdjson_result<size_t> count_fields() & noexcept;
  inline simdjson_result<std::string_view> raw_json() noexcept;
  #if SIMDJSON_SUPPORTS_CONCEPTS
  // TODO: move this code into object-inl.h
 
  template<typename T>
  simdjson_inline simdjson_result<T> get() noexcept(nothrow_gettable<T, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
    if (error()) { return error(); }
    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
      return first;
    }
    return first.get<T>();
  }
  template<typename T>
  simdjson_warn_unused simdjson_inline error_code get(T& out) noexcept(nothrow_gettable<T, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
    if (error()) { return error(); }
    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
      out = first;
    } else {
      SIMDJSON_TRY( first.get<T>(out) );
    }
    return SUCCESS;
  }
 
  template <typename Selector, typename Func>
    requires SIMDJSON_IMPLEMENTATION::ondemand::key_selector_type<Selector> &&
             std::is_invocable_v<Func&, std::size_t, SIMDJSON_IMPLEMENTATION::ondemand::value>
  simdjson_inline SIMDJSON_IMPLEMENTATION::ondemand::for_each_result for_each(Func&& on_match)
      noexcept(std::is_nothrow_invocable_v<Func&, std::size_t, SIMDJSON_IMPLEMENTATION::ondemand::value>);
 
  template <typename Selector, typename... Handlers>
    requires SIMDJSON_IMPLEMENTATION::ondemand::key_selector_type<Selector> &&
             (sizeof...(Handlers) == Selector::size()) &&
             (SIMDJSON_IMPLEMENTATION::ondemand::key_selector_for_each_detail::field_handler<Handlers> && ...)
  simdjson_inline SIMDJSON_IMPLEMENTATION::ondemand::for_each_result for_each(Handlers&&... on_match)
      noexcept(SIMDJSON_IMPLEMENTATION::ondemand::key_selector_for_each_detail::nothrow_field_handlers_v<Handlers...>);
 
  template <constevalutil::fixed_string... Keys, typename... Handlers>
    requires (sizeof...(Handlers) == sizeof...(Keys)) &&
             (sizeof...(Keys) >= 1) && (sizeof...(Keys) <= 255) &&
             (SIMDJSON_IMPLEMENTATION::ondemand::key_selector_for_each_detail::field_handler<Handlers> && ...)
  simdjson_inline SIMDJSON_IMPLEMENTATION::ondemand::for_each_result for_each(Handlers&&... on_match)
      noexcept(SIMDJSON_IMPLEMENTATION::ondemand::key_selector_for_each_detail::nothrow_field_handlers_v<Handlers...>);
 
#if SIMDJSON_STATIC_REFLECTION
  // TODO: move this code into object-inl.h
  template<constevalutil::fixed_string... FieldNames, typename T>
    requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))
  simdjson_warn_unused simdjson_inline error_code extract_into(T& out) noexcept {
    if (error()) { return error(); }
    return first.extract_into<FieldNames...>(out);
  }
#endif // SIMDJSON_STATIC_REFLECTION
#endif // SIMDJSON_SUPPORTS_CONCEPTS
};
 
} // namespace simdjson
 
#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_H