ranges.h

#ifndef SIMDJSON_GENERIC_ONDEMAND_RANGES_H
 
#ifndef SIMDJSON_CONDITIONAL_INCLUDE
#define SIMDJSON_GENERIC_ONDEMAND_RANGES_H
#include "simdjson/generic/ondemand/base.h"
#include "simdjson/generic/ondemand/array.h"
#include "simdjson/generic/ondemand/array_iterator.h"
#include "simdjson/generic/ondemand/object.h"
#include "simdjson/generic/ondemand/object_iterator.h"
#include "simdjson/generic/ondemand/field.h"
#include "simdjson/generic/ondemand/value.h"
#endif // SIMDJSON_CONDITIONAL_INCLUDE
 
#if SIMDJSON_SUPPORTS_RANGES
 
namespace simdjson {
namespace SIMDJSON_IMPLEMENTATION {
namespace ondemand {
 
class array_range_iterator {
public:
  using iterator_concept = std::input_iterator_tag;
  using value_type = simdjson_result<value>;
  using reference = simdjson_result<value>;
  using difference_type = std::ptrdiff_t;
 
  simdjson_inline array_range_iterator() noexcept = default;
  simdjson_inline explicit array_range_iterator(array_iterator iter) noexcept;
 
  simdjson_inline simdjson_result<value> operator*() const noexcept;
  simdjson_inline array_range_iterator& operator++() noexcept;
SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
  simdjson_inline void operator++(int) noexcept;
SIMDJSON_POP_DISABLE_WARNINGS
  simdjson_inline friend bool operator==(const array_range_iterator& a,
                                         const array_range_iterator& b) noexcept {
    return a.iter_ == b.iter_;
  }
 
private:
  mutable array_iterator iter_{};
};
 
class array_range {
public:
  simdjson_inline array_range() noexcept = default;
  simdjson_inline explicit array_range(array& arr) noexcept;
 
  simdjson_inline array_range_iterator begin() noexcept;
  simdjson_inline array_range_iterator end() noexcept;
 
  simdjson_inline error_code error() const noexcept { return error_; }
 
private:
  array_iterator begin_{};
  array_iterator end_{};
  error_code error_{SUCCESS};
};
 
class object_range_iterator {
public:
  using iterator_concept = std::input_iterator_tag;
  using value_type = simdjson_result<field>;
  using reference = simdjson_result<field>;
  using difference_type = std::ptrdiff_t;
 
  simdjson_inline object_range_iterator() noexcept = default;
  simdjson_inline explicit object_range_iterator(object_iterator iter) noexcept;
 
  simdjson_inline simdjson_result<field> operator*() const noexcept;
  simdjson_inline object_range_iterator& operator++() noexcept;
SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
  simdjson_inline void operator++(int) noexcept;
SIMDJSON_POP_DISABLE_WARNINGS
  simdjson_inline friend bool operator==(const object_range_iterator& a,
                                         const object_range_iterator& b) noexcept {
    return a.iter_ == b.iter_;
  }
 
private:
  mutable object_iterator iter_{};
};
 
class object_range {
public:
  simdjson_inline object_range() noexcept = default;
  simdjson_inline explicit object_range(object& obj) noexcept;
 
  simdjson_inline object_range_iterator begin() noexcept;
  simdjson_inline object_range_iterator end() noexcept;
 
  simdjson_inline error_code error() const noexcept { return error_; }
 
private:
  object_iterator begin_{};
  object_iterator end_{};
  error_code error_{SUCCESS};
};
 
simdjson_inline array_range get_range(array& arr) noexcept;
 
simdjson_inline object_range get_key_value_range(object& obj) noexcept;
 
#if SIMDJSON_EXCEPTIONS
simdjson_inline array_range get_range(simdjson_result<array> result);
 
simdjson_inline object_range get_key_value_range(simdjson_result<object> result);
#endif // SIMDJSON_EXCEPTIONS
 
} // namespace ondemand
} // namespace SIMDJSON_IMPLEMENTATION
} // namespace simdjson
 
namespace std {
namespace ranges {
template<>
inline constexpr bool enable_view<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::array_range> = true;
template<>
inline constexpr bool enable_view<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::object_range> = true;
} // namespace ranges
} // namespace std
 
#endif // SIMDJSON_SUPPORTS_RANGES
 
#endif // SIMDJSON_GENERIC_ONDEMAND_RANGES_H