daw_json_iterator.h

Go to the documentation of this file.

// Copyright (c) Darrell Wright
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/beached/daw_json_link
//
 
#pragma once
 
#include "daw/json/impl/version.h"
 
#include "daw/json/impl/daw_json_link_types_fwd.h"
#include "daw/json/impl/daw_json_parse_class.h"
#include "daw/json/impl/daw_json_parse_value_fwd.h"
 
#include <daw/daw_cxmath.h>
#include <daw/daw_move.h>
#include <daw/daw_string_view.h>
#include <daw/daw_traits.h>
#include <daw/daw_utility.h>
 
#include <array>
#include <cstddef>
#include <cstdlib>
#include <iterator>
#include <limits>
#include <optional>
#include <string>
#include <type_traits>
 
namespace daw::json {
  inline namespace DAW_JSON_VER {
    namespace json_details {
      template<typename T>
      struct assign_on_dtor {
        T &lhs;
        T const &rhs;
 
        DAW_ATTRIB_INLINE constexpr assign_on_dtor( T &Lhs,
                                                    T const &Rhs ) noexcept
          : lhs( Lhs )
          , rhs( Rhs ) {}
 
        DAW_ATTRIB_INLINE DAW_JSON_CPP20_CX_DTOR ~assign_on_dtor( ) noexcept {
          lhs = rhs;
        }
      };
 
      template<typename T>
      assign_on_dtor( T const &, T const & ) -> assign_on_dtor<T>;
 
      template<typename ParseState>
      [[nodiscard]] constexpr zstring_policy_t<ParseState>
      to_zstring_state( ParseState const &state ) {
        return zstring_policy_t<ParseState>( state.first,
                                              state.last,
                                              state.class_first,
                                              state.class_last,
                                              state.counter );
      }
    } // namespace json_details
    /***
     * Iterator for iterating over JSON array's
     * @tparam JsonElement type under underlying element in array. If
     * heterogeneous, a basic_json_value_iterator may be more appropriate
     * @note An exception from dereferencing or incrementing invalidates the
     * iterator. Before using it again, restore it by assigning a valid copy
     * saved before the operation that threw. Incrementing an invalidated
     * iterator is not a supported way to recover from a parsing error.
     * @tparam ParseState Parsing policy type
     */
    template<typename JsonElement, typename ParseState, typename = void>
    class json_array_iterator_t {
 
      static constexpr ParseState get_range( daw::string_view data,
                                             daw::string_view member_path ) {
        auto [result, is_found] = json_details::find_range<ParseState>(
          data, { std::data( member_path ), std::size( member_path ) } );
        daw_json_ensure( is_found, ErrorReason::JSONPathNotFound );
        daw_json_ensure(
          result.front( ) == '[', ErrorReason::InvalidArrayStart, result );
        return result;
      }
 
    public:
      using element_type = json_details::json_deduced_type<JsonElement>;
      static_assert( not std::is_same_v<element_type, void>,
                     "Unknown JsonElement type." );
      using value_type = json_details::json_result_t<element_type>;
      using reference = value_type;
      using pointer = json_details::arrow_proxy<value_type>;
      using difference_type = std::ptrdiff_t;
      // Can do forward iteration and be stored
      using iterator_category = std::input_iterator_tag;
 
    private:
      ParseState m_state = ParseState( );
      /***
       * This lets us fastpath and just skip n characters as we have already
       * parsed them
       */
      mutable char const *m_can_skip = nullptr;
 
      static constexpr bool can_use_zstring =
        json_details::can_use_runtime_zstring_v<ParseState, daw::string_view>;
 
      bool m_is_zstring = false;
 
      template<typename State>
      [[nodiscard]] constexpr value_type parse_current( State tmp ) const {
        auto const run_after_parse =
          json_details::assign_on_dtor{ m_can_skip, tmp.first };
        (void)run_after_parse;
        return json_details::
          parse_value<element_type, false, element_type::expected_type>( tmp );
      }
 
    public:
      explicit json_array_iterator_t( ) = default;
 
      explicit constexpr json_array_iterator_t( daw::string_view jd )
        : m_state( ParseState( std::data( jd ), daw::data_end( jd ) ) )
        , m_is_zstring( json_details::is_runtime_zstring<ParseState>( jd ) ) {
 
        m_state.trim_left( );
        daw_json_assert_weak( m_state.is_opening_bracket_checked( ),
                              ErrorReason::InvalidArrayStart,
                              m_state );
 
        m_state.remove_prefix( );
        m_state.trim_left( );
        daw_json_assert_weak(
          m_state.has_more( ), ErrorReason::UnexpectedEndOfData, m_state );
      }
 
      explicit constexpr json_array_iterator_t( daw::string_view jd,
                                                daw::string_view start_path )
        : m_state( get_range( jd, start_path ) )
        , m_is_zstring( json_details::is_runtime_zstring<ParseState>( jd ) ) {
 
        m_state.trim_left( );
        daw_json_assert_weak( m_state.is_opening_bracket_checked( ),
                              ErrorReason::InvalidArrayStart,
                              m_state );
 
        m_state.remove_prefix( );
        m_state.trim_left( );
        daw_json_assert_weak(
          m_state.has_more( ), ErrorReason::UnexpectedEndOfData, m_state );
      }
 
      constexpr json_array_iterator_t begin( ) const {
        return *this;
      }
 
      constexpr json_array_iterator_t end( ) const {
        return json_array_iterator_t( );
      }
 
      [[nodiscard]] constexpr value_type operator*( ) const {
        daw_json_assert_weak( m_state.has_more( ) and m_state.front( ) != ']',
                              ErrorReason::UnexpectedEndOfData,
                              m_state );
 
        if constexpr( can_use_zstring ) {
          if( m_is_zstring ) {
            return parse_current( json_details::to_zstring_state( m_state ) );
          }
        }
        return parse_current( m_state );
      }
 
      [[nodiscard]] pointer operator->( ) const {
        return pointer{ operator*( ) };
      }
 
      /***
       * Move the parse state to the next element
       * @return iterator after moving
       */
      constexpr json_array_iterator_t &operator++( ) {
        daw_json_assert_weak( m_state.has_more( ) and m_state.front( ) != ']',
                              ErrorReason::UnexpectedEndOfData,
                              m_state );
        if constexpr( can_use_zstring ) {
          if( m_is_zstring ) {
            auto state = json_details::to_zstring_state( m_state );
            move_next( state );
            m_state.first = state.first;
            return *this;
          }
        }
        move_next( m_state );
        return *this;
      }
 
    private:
      template<typename State>
      constexpr void move_next( State &state ) {
        if( m_can_skip ) {
          state.first = m_can_skip;
          m_can_skip = nullptr;
        } else {
          (void)json_details::skip_known_value<element_type>( state );
        }
        state.trim_left( );
        daw_json_assert_weak( state.has_more( ) and
                                state.is_at_next_array_element( ),
                              ErrorReason::UnexpectedEndOfData,
                              state );
 
        state.move_next_member_or_end( );
        state.trim_left( );
        daw_json_assert_weak(
          state.has_more( ), ErrorReason::UnexpectedEndOfData, state );
      }
 
    public:
 
      constexpr void operator++( int ) & {
        (void)operator++( );
      }
 
      /***
       * Is it ok to dereference iterator
       * @return true when there is parse data available
       */
      [[nodiscard]] constexpr bool good( ) const {
        return not m_state.is_null( ) and m_state.has_more( ) and
               m_state.front( ) != ']';
      }
 
      [[nodiscard]] explicit constexpr operator bool( ) const {
        return good( );
      }
 
      [[nodiscard]] constexpr bool
      operator==( json_array_iterator_t const &rhs ) const {
        auto const not_lhs = not( *this );
        auto const not_rhs = not( rhs );
        if( not_lhs ) {
          return not_rhs;
        }
        if( not_rhs ) {
          return false;
        }
        return ( m_state.first == rhs.m_state.first );
      }
 
      [[nodiscard]] constexpr bool
      operator!=( json_array_iterator_t const &rhs ) const {
        if( not( *this ) ) {
          return static_cast<bool>( rhs );
        }
        if( not rhs ) {
          return true;
        }
        return m_state.first != rhs.m_state.first;
      }
    };
 
    template<typename JsonElement, auto... PolicyFlags>
    using json_array_iterator = json_array_iterator_t<
      JsonElement,
      TryDefaultParsePolicy<BasicParsePolicy<
        options::details::make_parse_flags<PolicyFlags...>( ).value>>>;
    template<typename JsonElement, auto... PolicyFlags>
    class json_array_iterator_once {
      using ParseState = TryDefaultParsePolicy<BasicParsePolicy<
        options::details::make_parse_flags<PolicyFlags...>( ).value>>;
 
      static constexpr ParseState get_range( daw::string_view data,
                                             daw::string_view member_path ) {
        auto [result, is_found] = json_details::find_range<ParseState>(
          data, { std::data( member_path ), std::size( member_path ) } );
        daw_json_ensure( is_found, ErrorReason::JSONPathNotFound );
        daw_json_ensure(
          result.front( ) == '[', ErrorReason::InvalidArrayStart, result );
        return result;
      }
 
    public:
      using element_type = json_details::json_deduced_type<JsonElement>;
      static_assert( not std::is_same_v<element_type, void>,
                     "Unknown JsonElement type." );
      using value_type = json_details::json_result_t<element_type>;
      using reference = value_type;
      using pointer = json_details::arrow_proxy<value_type>;
      using difference_type = std::ptrdiff_t;
 
    private:
      mutable ParseState m_state = ParseState( );
 
      static constexpr bool can_use_zstring =
        json_details::can_use_runtime_zstring_v<ParseState, daw::string_view>;
 
      bool m_is_zstring = false;
 
    public:
      explicit json_array_iterator_once( ) = default;
 
      explicit constexpr json_array_iterator_once( daw::string_view jd )
        : m_state( ParseState( std::data( jd ), daw::data_end( jd ) ) )
        , m_is_zstring( json_details::is_runtime_zstring<ParseState>( jd ) ) {
 
        m_state.trim_left( );
        daw_json_assert_weak( m_state.is_opening_bracket_checked( ),
                              ErrorReason::InvalidArrayStart,
                              m_state );
 
        m_state.remove_prefix( );
        m_state.trim_left( );
        daw_json_assert_weak(
          m_state.has_more( ), ErrorReason::UnexpectedEndOfData, m_state );
      }
 
      explicit constexpr json_array_iterator_once( daw::string_view jd,
                                                   daw::string_view start_path )
        : m_state( get_range( jd, start_path ) )
        , m_is_zstring( json_details::is_runtime_zstring<ParseState>( jd ) ) {
 
        m_state.trim_left( );
        daw_json_assert_weak( m_state.is_opening_bracket_checked( ),
                              ErrorReason::InvalidArrayStart,
                              m_state );
 
        m_state.remove_prefix( );
        m_state.trim_left( );
        daw_json_assert_weak(
          m_state.has_more( ), ErrorReason::UnexpectedEndOfData, m_state );
      }
 
      [[nodiscard]] constexpr value_type operator*( ) const {
        daw_json_assert_weak( m_state.has_more( ) and m_state.front( ) != ']',
                              ErrorReason::UnexpectedEndOfData,
                              m_state );
 
        if constexpr( can_use_zstring ) {
          if( m_is_zstring ) {
            auto state = json_details::to_zstring_state( m_state );
            auto const run_after_parse =
              json_details::assign_on_dtor{ m_state.first, state.first };
            (void)run_after_parse;
            return json_details::
              parse_value<element_type, false, element_type::expected_type>(
                state );
          }
        }
        return json_details::
          parse_value<element_type, false, element_type::expected_type>(
            m_state );
      }
 
      /***
       * Move the parse state to the next element
       * @return iterator after moving
       */
      constexpr json_array_iterator_once &operator++( ) {
        daw_json_assert_weak( m_state.has_more( ) and
                                m_state.is_at_next_array_element( ),
                              ErrorReason::UnexpectedEndOfData,
                              m_state );
        if constexpr( can_use_zstring ) {
          if( m_is_zstring ) {
            auto state = json_details::to_zstring_state( m_state );
            state.move_next_member_or_end( );
            m_state.first = state.first;
          } else {
            m_state.move_next_member_or_end( );
          }
        } else {
          m_state.move_next_member_or_end( );
        }
        daw_json_assert_weak(
          m_state.has_more( ), ErrorReason::UnexpectedEndOfData, m_state );
        return *this;
      }
 
      constexpr void operator++( int ) & {
        (void)operator++( );
      }
 
      /***
       * Is it ok to dereference iterator
       * @return true when there is parse data available
       */
      [[nodiscard]] constexpr bool good( ) const {
        return not m_state.is_null( ) and m_state.has_more( ) and
               m_state.front( ) != ']';
      }
 
      [[nodiscard]] explicit constexpr operator bool( ) const {
        return good( );
      }
 
      [[nodiscard]] constexpr bool
      operator==( json_array_iterator_once const &rhs ) const {
        auto const not_lhs = not( *this );
        auto const not_rhs = not( rhs );
        if( not_lhs ) {
          return not_rhs;
        }
        if( not_rhs ) {
          return false;
        }
        return ( m_state.first == rhs.m_state.first );
      }
 
      [[nodiscard]] constexpr bool
      operator!=( json_array_iterator_once const &rhs ) const {
        auto const not_lhs = not( *this );
        auto const not_rhs = not( rhs );
        if( not_lhs ) {
          return not not_rhs;
        }
        if( not_rhs ) {
          return true;
        }
        return m_state.first != rhs.m_state.first;
      }
    };
 
    template<typename JsonElement, auto... PolicyFlags>
    struct json_array_range {
      using ParsePolicy = TryDefaultParsePolicy<BasicParsePolicy<
        options::details::make_parse_flags<PolicyFlags...>( ).value>>;
      using iterator = json_array_iterator<JsonElement, PolicyFlags...>;
 
    private:
      iterator m_first{ };
      iterator m_last{ };
 
    public:
      explicit json_array_range( ) = default;
 
      explicit constexpr json_array_range( daw::string_view jd )
        : m_first( jd ) {}
 
      explicit constexpr json_array_range( daw::string_view jd,
                                           daw::string_view start_path )
        : m_first( jd, start_path ) {}
 
      [[nodiscard]] constexpr iterator begin( ) const {
        return m_first;
      }
 
      [[nodiscard]] constexpr iterator end( ) const {
        return m_last;
      }
 
      [[nodiscard]] constexpr bool empty( ) const {
        return m_first == m_last;
      }
    };
 
    template<typename JsonElement, auto... PolicyFlags>
    struct json_array_range_once {
      using ParsePolicy = TryDefaultParsePolicy<BasicParsePolicy<
        options::details::make_parse_flags<PolicyFlags...>( ).value>>;
      using iterator = json_array_iterator_once<JsonElement, PolicyFlags...>;
 
    private:
      iterator m_first{ };
      iterator m_last{ };
 
    public:
      json_array_range_once( ) = default;
 
      explicit constexpr json_array_range_once( daw::string_view jd )
        : m_first( jd ) {}
 
      explicit constexpr json_array_range_once( daw::string_view jd,
                                                daw::string_view start_path )
        : m_first( jd, start_path ) {}
 
      [[nodiscard]] constexpr iterator begin( ) const {
        return m_first;
      }
 
      [[nodiscard]] constexpr iterator end( ) const {
        return m_last;
      }
 
      [[nodiscard]] constexpr bool empty( ) const {
        return m_first == m_last;
      }
    };
  } // namespace DAW_JSON_VER
} // namespace daw::json