daw_json_assert.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/daw_json_exception.h"
 
#include <daw/daw_attributes.h>
#include <daw/daw_cpp_feature_check.h>
#include <daw/daw_likely.h>
#include <daw/daw_not_null.h>
#include <daw/daw_static_warn_if.h>
 
#include <cstddef>
#include <daw/stdinc/move_fwd_exch.h>
#include <exception>
#include <string_view>
#include <utility>
 
#if defined( DAW_JSON_SHOW_ERROR_BEFORE_TERMINATE )
#include <iostream>
#endif
 
namespace daw::json {
#if defined( DAW_USE_EXCEPTIONS )
  inline constexpr bool use_daw_json_exceptions_v = true;
#else
  inline constexpr bool use_daw_json_exceptions_v = false;
#endif
 
  inline thread_local void *daw_json_error_handler_data = nullptr;
 
#if defined( DAW_USE_EXCEPTIONS )
  [[noreturn, maybe_unused]] DAW_ATTRIB_NOINLINE inline void
  default_error_handler_throwing( json_exception &&jex, void * ) {
    throw std::move( jex );
  }
#endif
 
  [[noreturn, maybe_unused]] DAW_ATTRIB_NOINLINE inline void
  default_error_handler_terminating( json_exception &&jex, void * ) {
#if defined( DAW_JSON_SHOW_ERROR_BEFORE_TERMINATE )
    std::cerr << "Error: " << jex.reason( ) << '\n';
#else
    (void)jex;
#endif
    std::terminate( );
  }
 
  using daw_json_error_handler_t =
    daw::not_null<void ( * )( json_exception &&, void * )>;
 
#if defined( DAW_USE_EXCEPTIONS )
  inline thread_local daw_json_error_handler_t daw_json_error_handler =
    default_error_handler_throwing;
#else
  inline thread_local daw_json_error_handler_t daw_json_error_handler =
    default_error_handler_terminating;
#endif
 
  inline namespace DAW_JSON_VER {
    namespace json_details {
#if defined( DAW_ATTRIB_ENABLE_IF )
#if defined( DAW_HAS_CPP26_DELETED_REASON )
      [[noreturn]] DAW_ATTRIB_NOINLINE inline void
      handle_error( bool b, json_exception &&jex )
        DAW_ATTRIB_ENABLE_IF( __builtin_constant_p( b ) and b,
                              "daw_json_ensure check failed" ) =
          delete( "daw_json_ensure check failed" );
#endif
      [[noreturn]] DAW_ATTRIB_NOINLINE inline void
      handle_error( bool b, json_exception &&jex )
        DAW_ATTRIB_ENABLE_IF( __builtin_constant_p( b ) and not b,
                              "daw_json_ensure check failed" ) {
        daw_json_error_handler.get( )( std::move( jex ),
                                       daw_json_error_handler_data );
        DAW_UNREACHABLE( );
      }
 
      [[noreturn]] DAW_ATTRIB_NOINLINE inline void
      handle_error( bool b, json_exception &&jex )
        DAW_ATTRIB_ENABLE_IF( not __builtin_constant_p( b ), " " ) {
        daw_json_error_handler.get( )( std::move( jex ),
                                       daw_json_error_handler_data );
        DAW_UNREACHABLE( );
      }
#else
      [[noreturn]] DAW_ATTRIB_NOINLINE inline void
      handle_error( bool, json_exception &&jex ) {
        daw_json_error_handler.get( )( std::move( jex ),
                                       daw_json_error_handler_data );
        DAW_UNREACHABLE( );
      }
#endif
    } // namespace json_details
 
    [[noreturn]] DAW_ATTRIB_NOINLINE inline void
    daw_json_error( bool b, ErrorReason reason ) {
      json_details::handle_error( b, json_exception( reason ) );
    }
 
    template<typename ParseState>
    [[noreturn]] DAW_ATTRIB_NOINLINE inline void
    daw_json_error( bool b, ErrorReason reason, ParseState const &location ) {
      if( location.first ) {
        json_details::handle_error( b,
                                    json_exception( reason, location.first ) );
      }
      if( location.class_first ) {
        json_details::handle_error(
          b, json_exception( reason, location.class_first ) );
      }
      json_details::handle_error( b, json_exception( reason ) );
    }
 
    [[noreturn]] DAW_ATTRIB_NOINLINE inline void
    daw_json_error( bool b, json_details::missing_member reason ) {
      json_details::handle_error( b, json_exception( reason ) );
    }
 
    [[noreturn]] DAW_ATTRIB_NOINLINE inline void
    daw_json_error( bool b, json_details::missing_token reason ) {
      json_details::handle_error( b, json_exception( reason ) );
    }
 
    template<typename ParseState>
    [[noreturn]] DAW_ATTRIB_NOINLINE inline void
    daw_json_error( bool b, json_details::missing_member reason,
                    ParseState const &location ) {
      if( location.class_first and location.first ) {
        static constexpr std::size_t max_len = 150;
        std::size_t const len = [&]( ) -> std::size_t {
          if( location.first == nullptr or location.class_first == nullptr ) {
            if( location.class_first == nullptr or
                location.class_last == nullptr ) {
              return 0;
            }
            auto const dist = static_cast<std::size_t>( location.class_last -
                                                        location.class_first );
            if( dist < max_len ) {
              return dist;
            }
            return max_len;
          }
          auto const dist = static_cast<std::size_t>( location.class_first -
                                                      location.first + 1 );
          if( dist < max_len ) {
            return dist;
          }
          return max_len;
        }( );
        json_details::handle_error(
          b,
          json_exception( reason,
                          std::string_view( location.class_first, len ) ) );
      }
      json_details::handle_error( b, json_exception( reason ) );
    }
 
    template<typename ParseState>
    [[noreturn]] DAW_ATTRIB_NOINLINE inline void
    daw_json_error( bool b, json_details::missing_token reason,
                    ParseState const &location ) {
      if( location.first ) {
        json_details::handle_error( b,
                                    json_exception( reason, location.first ) );
      }
      if( location.class_first ) {
        json_details::handle_error(
          b, json_exception( reason, location.class_first ) );
      }
      json_details::handle_error( b, json_exception( reason ) );
    }
  } // namespace DAW_JSON_VER
} // namespace daw::json
 
#define daw_json_ensure( Bool, ... )                                       \
  do {                                                                     \
    if( DAW_UNLIKELY( not( Bool ) ) ) {                                    \
      daw_static_warn_if( not( Bool ),                                     \
                          "Error handler will always be called: " #Bool ); \
      daw_json_error( not( Bool ), __VA_ARGS__ );                          \
    }                                                                      \
  } while( false )
 
#if defined( DAW_HAS_IF_CONSTEVAL )
#define daw_json_assert_weak( Bool, ... )                                      \
  do {                                                                         \
    if consteval {                                                             \
      if( DAW_UNLIKELY( not( Bool ) ) ) {                                      \
        daw_json_error( not( Bool ), __VA_ARGS__ );                            \
      }                                                                        \
    } else {                                                                   \
      if constexpr( not ParseState::is_unchecked_input ) {                     \
        if( DAW_UNLIKELY( not( Bool ) ) ) {                                    \
          daw_static_warn_if( not( Bool ),                                     \
                              "Error handler will always be called: " #Bool ); \
          daw_json_error( not( Bool ), __VA_ARGS__ );                          \
        }                                                                      \
      }                                                                        \
    }                                                                          \
  } while( false )
#elif defined( DAW_HAS_IS_CONSTANT_EVALUATED )
#define daw_json_assert_weak( Bool, ... )                                      \
  do {                                                                         \
    if( DAW_IS_CONSTANT_EVALUATED( ) ) {                                       \
      if( DAW_UNLIKELY( not( Bool ) ) ) {                                      \
        daw_json_error( not( Bool ), __VA_ARGS__ );                            \
      }                                                                        \
    } else {                                                                   \
      if constexpr( not ParseState::is_unchecked_input ) {                     \
        if( DAW_UNLIKELY( not( Bool ) ) ) {                                    \
          daw_static_warn_if( not( Bool ),                                     \
                              "Error handler will always be called: " #Bool ); \
          daw_json_error( not( Bool ), __VA_ARGS__ );                          \
        }                                                                      \
      }                                                                        \
    }                                                                          \
  } while( false )
#else
#define daw_json_assert_weak( Bool, ... )                                    \
  do {                                                                       \
    if constexpr( not ParseState::is_unchecked_input ) {                     \
      if( DAW_UNLIKELY( not( Bool ) ) ) {                                    \
        daw_static_warn_if( not( Bool ),                                     \
                            "Error handler will always be called: " #Bool ); \
        daw_json_error( not( Bool ), __VA_ARGS__ );                          \
      }                                                                      \
    }                                                                        \
  } while( false )
#endif
 
#if defined( DEBUG ) or not defined( NDEBUG )
#define daw_json_dbg_ensure( Bool, ... )                                   \
  do {                                                                     \
    if( DAW_UNLIKELY( not( Bool ) ) ) {                                    \
      daw_static_warn_if( not( Bool ),                                     \
                          "Error handler will always be called: " #Bool ); \
      daw_json_error( not( Bool ), __VA_ARGS__ );                          \
    }                                                                      \
  } while( false )
 
#else
#define daw_json_dbg_ensure( ... ) \
  do {                             \
  } while( false )
#endif