daw_json_location_info.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_assert.h"
#include "daw/json/impl/daw_json_find_result.h"
#include "daw/json/impl/daw_json_parse_name.h"
 
#include <daw/daw_consteval.h>
#include <daw/daw_likely.h>
#include <daw/daw_logic.h>
#include <daw/daw_string_view.h>
#include <daw/daw_traits.h>
 
#include <cstddef>
#include <daw/stdinc/data_access.h>
#include <string>
 
#if defined( DAW_JSON_PARSER_DIAGNOSTICS )
#include <cmath>
#include <iostream>
#endif
 
namespace daw::json {
  inline namespace DAW_JSON_VER {
    namespace json_details {
      [[nodiscard]] DAW_ATTRIB_INLINE constexpr bool
      names_equal( daw::string_view lhs, daw::string_view rhs ) {
        return std::size( lhs ) == std::size( rhs ) and
               std::char_traits<char>::compare( std::data( lhs ),
                                                std::data( rhs ),
                                                std::size( lhs ) ) == 0;
      }
 
      template<typename Iterator = char const *>
      struct location_info_t {
        daw::string_view name;
        Iterator first = nullptr;
        Iterator last = nullptr;
        Iterator class_first = nullptr;
        Iterator class_last = nullptr;
        std::size_t counter = 0;
 
        [[nodiscard]] constexpr bool missing( ) const {
          return first == nullptr;
        }
 
        template<typename ParseState>
        constexpr void set_range( ParseState const &parse_state ) {
          first = parse_state.first;
          last = parse_state.last;
          class_first = parse_state.class_first;
          class_last = parse_state.class_last;
          counter = parse_state.counter;
        }
 
        template<typename ParseState>
        constexpr auto get_range( ) const {
          using range_t = typename ParseState::without_allocator_type;
          return range_t( first, last, class_first, class_last, counter );
        }
      };
 
      /***
       * Contains an array of member location_info mapped in a json_class
       * @tparam MemberCount Number of mapped members from json_class
       */
      template<std::size_t MemberCount, typename Iterator = char const *>
      struct locations_info_t {
        using value_type = location_info_t<Iterator>;
        using reference = value_type &;
        using const_reference = value_type const &;
        value_type names[MemberCount];
 
        constexpr const_reference operator[]( std::size_t idx ) const {
          daw_json_ensure( idx < MemberCount, ErrorReason::NumberOutOfRange );
          return names[idx];
        }
 
        constexpr reference operator[]( std::size_t idx ) {
          daw_json_ensure( idx < MemberCount, ErrorReason::NumberOutOfRange );
          return names[idx];
        }
 
        static constexpr std::size_t size( ) {
          return MemberCount;
        }
 
        template<std::size_t start_pos>
        [[nodiscard]] DAW_ATTRIB_INLINE constexpr std::size_t
        find_name( daw::string_view key ) const {
#if defined( DAW_JSON_BUGFIX_MSVC_EVAL_ORDER_002 )
          (void)start_pos;
          constexpr std::size_t first_pos = 0;
#else
          constexpr std::size_t first_pos = start_pos;
#endif
          for( std::size_t n = first_pos; n < MemberCount; ++n ) {
            if( names_equal( key, names[n].name ) ) {
              return n;
            }
          }
          return MemberCount;
        }
      };
 
      // Should never be called outside a consteval context
      template<typename ParseState, typename... JsonMembers>
      DAW_ATTRIB_FLATINLINE static DAW_JSON_MAKE_LOC_INFO_CONSTEVAL auto
      make_locations_info( ) {
        return locations_info_t<sizeof...( JsonMembers ),
                                typename ParseState::iterator>{
          /*names*/ { location_info_t<typename ParseState::iterator>{ JsonMembers::name }... } };
      }
 
      /***
       * Get the position from already seen JSON members or move the parser
       * forward until we reach the end of the class or the member.
       * @tparam N Number of members in json_class
       * @tparam ParseState see IteratorRange
       * @param locations members location and names
       * @param parse_state Current JSON data
       * @return IteratorRange with begin( ) being start of value
       */
      enum class AllMembersMustExist { yes, no };
 
      template<typename ParseState>
      [[nodiscard]] DAW_ATTRIB_INLINE static constexpr bool
      match_expected_name( ParseState const &parse_state,
                           daw::string_view expected ) {
        auto const sz = std::size( expected );
        return parse_state.size( ) > sz + 1U and
               parse_state.first[0] == '"' and
               parse_state.first[sz + 1U] == '"' and
               ( sz == 0 or expected[sz - 1U] != '\\' ) and
               std::char_traits<char>::compare(
                 parse_state.first + 1, std::data( expected ), sz ) == 0;
      }
 
      template<std::size_t pos, AllMembersMustExist must_exist,
               bool from_start = false, std::size_t N, typename ParseState>
      [[nodiscard]] DAW_ATTRIB_INLINE static constexpr find_result<ParseState>
      find_class_member( ParseState &parse_state,
                         locations_info_t<N, typename ParseState::iterator> &locations, bool is_nullable,
                         daw::string_view member_name ) {
 
        // silencing gcc9 warning as these are selectively used
        (void)is_nullable;
        (void)member_name;
 
        daw_json_assert_weak(
          nsc_or( is_nullable,
                  ( not locations[pos].missing( ) ),
                  ( not parse_state.is_closing_brace_checked( ) ) ),
          missing_member( member_name ),
          parse_state );
 
        parse_state.trim_left_unchecked( );
        bool known = not locations[pos].missing( );
        while( nsc_and(
          locations[pos].missing( ),
          ( not parse_state.empty( ) and parse_state.front( ) != '}' ) ) ) {
          // Members usually arrive in mapped order, so try the expected name
          // first.  Its size is known, so only the closing quote needs
          // checking and the name does not need to be scanned
          // name_pos is initialized for C++17 constexpr, the store is elided
          std::size_t name_pos = std::size( locations );
          if( auto const expected = locations[pos].name;
              match_expected_name( parse_state, expected ) ) {
            parse_state.remove_prefix( std::size( expected ) + 2U );
            name::name_parser::trim_end_of_name( parse_state );
            name_pos = pos;
          } else {
            // TODO: fully unescape name
            // parse_name checks if we have more and are quotes
            auto const name = parse_name( parse_state );
            name_pos =
              locations.template find_name<( from_start ? 0 : pos )>( name );
          }
          if constexpr( must_exist == AllMembersMustExist::yes ) {
            daw_json_assert_weak( name_pos < std::size( locations ),
                                  ErrorReason::UnknownMember,
                                  parse_state );
          } else {
#if defined( DAW_JSON_PARSER_DIAGNOSTICS )
            std::cerr << "DEBUG: Unknown member '" << name << '\n';
#endif
            if( name_pos >= std::size( locations ) ) {
              // This is not a member we are concerned with
              (void)skip_value( parse_state );
              parse_state.move_next_member_or_end( );
              continue;
            }
          }
          if( name_pos == pos ) {
            locations[pos].set_range( parse_state );
            break;
          } else {
#if defined( DAW_JSON_PARSER_DIAGNOSTICS )
            std::cerr << "DEBUG:  Out of order member '"
                      << locations.names[name_pos].name
                      << "' found, looking for '" << locations.names[pos].name
                      << ". It is "
                      << std::abs( static_cast<long long>( pos ) -
                                   static_cast<long long>( name_pos ) )
                      << " members ahead in constructor\n";
#endif
            // We are out of order, store position for later
            // OLDTODO: use type knowledge to speed up skip
            // OLDTODO: on skipped classes see if way to store
            //        member positions so that we don't have to
            //        re-parse them after
            // RESULT: storing preparsed is slower, don't try 3 times
            // it also limits the type of things we can parse potentially
            // Using locations to switch on BaseType is slower too
            locations[name_pos].set_range( skip_value( parse_state ) );
 
            if constexpr( ParseState::is_unchecked_input ) {
              if( name_pos + 1 < std::size( locations ) ) {
                parse_state.move_next_member( );
              } else {
                parse_state.move_next_member_or_end( );
              }
            } else {
              parse_state.move_next_member_or_end( );
            }
          }
        }
        if( locations[pos].missing( ) ) {
          known = true;
        }
        if constexpr( ParseState::has_allocator ) {
          return find_result{
            locations[pos].template get_range<ParseState>( ).with_allocator(
              parse_state ),
            known };
        } else {
          return find_result<ParseState>{
            locations[pos].template get_range<ParseState>( ), known };
        }
      }
    } // namespace json_details
  } // namespace DAW_JSON_VER
} // namespace daw::json