couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

data/ext/third_party/json/include/tao/json/msgpack/parts_parser.hpp

@@ -1,311 +0,0 @@
-// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#ifndef TAO_JSON_MSGPACK_PARTS_PARSER_HPP
-#define TAO_JSON_MSGPACK_PARTS_PARSER_HPP
-
-#include <cstdint>
-#include <optional>
-
-#include "../events/discard.hpp"
-#include "../external/pegtl/string_input.hpp"
-#include "../utf8.hpp"
-
-#include "internal/format.hpp"
-#include "internal/grammar.hpp"
-
-namespace tao::json::msgpack
-{
-   namespace internal
-   {
-      template< typename Input >
-      [[nodiscard]] format peek_format( Input& in )
-      {
-         return format( json::internal::peek_uint8( in ) );
-      }
-
-      template< typename Input >
-      [[nodiscard]] bool read_boolean( Input& in )
-      {
-         const auto b = internal::peek_format( in );
-         switch( b ) {
-            case internal::format::BOOL_TRUE:
-            case internal::format::BOOL_FALSE:
-               in.bump_in_this_line( 1 );
-               return bool( b & 1 );
-            default:
-               throw pegtl::parse_error( "expected boolean", in );
-         }
-         std::abort();
-      }
-
-      template< typename Input >
-      [[nodiscard]] tao::binary_view read_binary( Input& in )
-      {
-         switch( peek_format( in ) ) {
-            case format::BIN8:
-               return json::internal::read_string< utf8_mode::trust, tao::binary_view >( in, json::internal::read_big_endian_number< std::size_t, std::uint8_t >( in, 1 ) );
-            case format::BIN16:
-               return json::internal::read_string< utf8_mode::trust, tao::binary_view >( in, json::internal::read_big_endian_number< std::size_t, std::uint16_t >( in, 1 ) );
-            case format::BIN32:
-               return json::internal::read_string< utf8_mode::trust, tao::binary_view >( in, json::internal::read_big_endian_number< std::size_t, std::uint32_t >( in, 1 ) );
-            default:
-               throw pegtl::parse_error( "expected binary data", in );
-         }
-      }
-
-      [[nodiscard]] inline std::int64_t test_signed( const std::uint64_t i )
-      {
-         if( ( i & ( std::uint64_t( 1 ) << 63 ) ) != 0 ) {
-            throw std::runtime_error( "integer overflow for signed" );
-         }
-         return std::int64_t( i );
-      }
-
-      template< typename Input >
-      [[nodiscard]] std::int64_t read_signed( Input& in )
-      {
-         const auto b = json::internal::peek_uint8( in );
-         if( b <= std::uint8_t( format::POSITIVE_MAX ) ) {
-            in.bump_in_this_line();
-            return std::int64_t( b );
-         }
-         if( b >= std::uint8_t( format::NEGATIVE_MIN ) ) {
-            in.bump_in_this_line();
-            return std::int64_t( std::int8_t( b ) );
-         }
-         switch( format( b ) ) {
-            case format::UINT8:
-               return json::internal::read_big_endian_number< std::int64_t, std::uint8_t >( in, 1 );
-            case format::UINT16:
-               return json::internal::read_big_endian_number< std::int64_t, std::uint16_t >( in, 1 );
-            case format::UINT32:
-               return json::internal::read_big_endian_number< std::int64_t, std::uint32_t >( in, 1 );
-            case format::UINT64:
-               return test_signed( json::internal::read_big_endian_number< std::uint64_t >( in, 1 ) );
-            case format::INT8:
-               return json::internal::read_big_endian_number< std::int64_t, std::int8_t >( in, 1 );
-            case format::INT16:
-               return json::internal::read_big_endian_number< std::int64_t, std::int16_t >( in, 1 );
-            case format::INT32:
-               return json::internal::read_big_endian_number< std::int64_t, std::int32_t >( in, 1 );
-            case format::INT64:
-               return json::internal::read_big_endian_number< std::int64_t >( in, 1 );
-            default:
-               throw pegtl::parse_error( "expected signed number", in );
-         }
-      }
-
-      [[nodiscard]] inline std::uint64_t test_unsigned( const std::int64_t i )
-      {
-         if( i < 0 ) {
-            throw std::runtime_error( "negative number for unsigned" );
-         }
-         return std::uint64_t( i );
-      }
-
-      template< typename Input >
-      [[nodiscard]] std::uint64_t read_unsigned( Input& in )
-      {
-         const auto b = json::internal::peek_uint8( in );
-         if( b <= std::uint8_t( format::POSITIVE_MAX ) ) {
-            in.bump_in_this_line();
-            return std::uint64_t( b );
-         }
-         switch( format( b ) ) {
-            case format::UINT8:
-               return json::internal::read_big_endian_number< std::uint64_t, std::uint8_t >( in, 1 );
-            case format::UINT16:
-               return json::internal::read_big_endian_number< std::uint64_t, std::uint16_t >( in, 1 );
-            case format::UINT32:
-               return json::internal::read_big_endian_number< std::uint64_t, std::uint32_t >( in, 1 );
-            case format::UINT64:
-               return json::internal::read_big_endian_number< std::uint64_t >( in, 1 );
-            case format::INT8:
-               return test_unsigned( json::internal::read_big_endian_number< std::int64_t, std::int8_t >( in, 1 ) );
-            case format::INT16:
-               return test_unsigned( json::internal::read_big_endian_number< std::int64_t, std::int16_t >( in, 1 ) );
-            case format::INT32:
-               return test_unsigned( json::internal::read_big_endian_number< std::int64_t, std::int32_t >( in, 1 ) );
-            case format::INT64:
-               return test_unsigned( json::internal::read_big_endian_number< std::int64_t >( in, 1 ) );
-            default:
-               throw pegtl::parse_error( "expected positive number", in );
-         }
-      }
-
-      template< typename Input >
-      [[nodiscard]] double read_double( Input& in )
-      {
-         switch( peek_format( in ) ) {
-            case format::FLOAT32:
-               return json::internal::read_big_endian_number< double, float >( in, 1 );
-            case format::FLOAT64:
-               return json::internal::read_big_endian_number< double >( in, 1 );
-            default:
-               throw pegtl::parse_error( "expected floating point number", in );
-         }
-      }
-
-      template< format Min, format Max, format S16, format S32, typename Input >
-      [[nodiscard]] std::size_t read_container_size( Input& in )
-      {
-         const auto b = json::internal::peek_uint8( in );
-         if( ( std::uint8_t( Min ) <= b ) && ( b <= std::uint8_t( Max ) ) ) {
-            in.bump_in_this_line();
-            return state_t( b - std::uint8_t( Min ) );
-         }
-         switch( format( b ) ) {
-            case S16:
-               return state_t( json::internal::read_big_endian_number< std::size_t, std::uint16_t >( in, 1 ) );
-            case S32:
-               return state_t( json::internal::read_big_endian_number< std::size_t, std::uint32_t >( in, 1 ) );
-            default:
-               throw pegtl::parse_error( "expected container", in );
-         }
-      }
-
-   }  // namespace internal
-
-   template< utf8_mode V = utf8_mode::check, typename Input = pegtl::string_input< pegtl::tracking_mode::lazy > >
-   class basic_parts_parser
-   {
-   public:
-      template< typename... Ts >
-      explicit basic_parts_parser( Ts&&... ts )
-         : m_input( std::forward< Ts >( ts )... )
-      {}
-
-      [[nodiscard]] bool empty()
-      {
-         return m_input.empty();
-      }
-
-      [[nodiscard]] bool null()
-      {
-         if( internal::peek_format( m_input ) == internal::format::NIL ) {
-            m_input.bump_in_this_line( 1 );
-            return true;
-         }
-         return false;
-      }
-
-      [[nodiscard]] bool boolean()
-      {
-         return internal::read_boolean( m_input );
-      }
-
-      [[nodiscard]] std::string_view string()
-      {
-         return internal::read_string< V >( m_input );
-      }
-
-      [[nodiscard]] tao::binary_view binary()
-      {
-         return internal::read_binary( m_input );
-      }
-
-      [[nodiscard]] std::string_view key()
-      {
-         return internal::read_string< V >( m_input );
-      }
-
-      [[nodiscard]] std::int64_t number_signed()
-      {
-         return internal::read_signed( m_input );
-      }
-
-      [[nodiscard]] std::uint64_t number_unsigned()
-      {
-         return internal::read_unsigned( m_input );
-      }
-
-      [[nodiscard]] double number_double()
-      {
-         return internal::read_double( m_input );
-      }
-
-      struct state_t
-      {
-         explicit state_t( const std::size_t in_size )
-            : size( in_size )
-         {}
-
-         std::size_t i = 0;
-         std::size_t size;
-      };
-
-      [[nodiscard]] state_t begin_array()
-      {
-         return state_t( internal::read_container_size< internal::format::FIXARRAY_MIN, internal::format::FIXARRAY_MAX, internal::format::ARRAY16, internal::format::ARRAY32 >( m_input ) );
-      }
-
-      [[nodiscard]] state_t begin_object()
-      {
-         return state_t( internal::read_container_size< internal::format::FIXMAP_MIN, internal::format::FIXMAP_MAX, internal::format::MAP16, internal::format::MAP32 >( m_input ) );
-      }
-
-      void end_array( state_t& p )
-      {
-         if( p.size != p.i ) {
-            throw pegtl::parse_error( "array size mismatch", m_input );
-         }
-      }
-
-      void end_object( state_t& p )
-      {
-         if( p.size != p.i ) {
-            throw pegtl::parse_error( "object size mismatch", m_input );
-         }
-      }
-
-      void element( state_t& p )
-      {
-         if( p.i++ >= p.size ) {
-            throw pegtl::parse_error( "unexpected array end", m_input );
-         }
-      }
-
-      void member( state_t& p )
-      {
-         if( p.i++ >= p.size ) {
-            throw pegtl::parse_error( "unexpected object end", m_input );
-         }
-      }
-
-      [[nodiscard]] bool element_or_end_array( state_t& p )
-      {
-         return p.i++ < p.size;
-      }
-
-      [[nodiscard]] bool member_or_end_object( state_t& p )
-      {
-         return p.i++ < p.size;
-      }
-
-      void skip_value()
-      {
-         json::events::discard consumer;  // TODO: Optimise to not generate events (which requires preparing their - discarded - arguments)?
-         pegtl::parse< pegtl::must< internal::data< V > > >( m_input, consumer );
-      }
-
-      [[nodiscard]] auto mark()
-      {
-         return m_input.template mark< pegtl::rewind_mode::required >();
-      }
-
-      template< typename T >
-      void throw_parse_error( T&& t ) const
-      {
-         throw pegtl::parse_error( std::forward< T >( t ), m_input );
-      }
-
-   protected:
-      Input m_input;
-   };
-
-   using parts_parser = basic_parts_parser<>;
-
-}  // namespace tao::json::msgpack
-
-#endif

data/ext/third_party/json/include/tao/json/msgpack/to_stream.hpp

@@ -1,27 +0,0 @@
-// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#ifndef TAO_JSON_MSGPACK_TO_STREAM_HPP
-#define TAO_JSON_MSGPACK_TO_STREAM_HPP
-
-#include <ostream>
-
-#include "../value.hpp"
-
-#include "../events/from_value.hpp"
-#include "../events/transformer.hpp"
-
-#include "events/to_stream.hpp"
-
-namespace tao::json::msgpack
-{
-   template< template< typename... > class... Transformers, template< typename... > class Traits >
-   void to_stream( std::ostream& os, const basic_value< Traits >& v )
-   {
-      json::events::transformer< events::to_stream, Transformers... > consumer( os );
-      json::events::from_value( consumer, v );
-   }
-
-}  // namespace tao::json::msgpack
-
-#endif

data/ext/third_party/json/include/tao/json/msgpack/to_string.hpp

@@ -1,28 +0,0 @@
-// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#ifndef TAO_JSON_MSGPACK_TO_STRING_HPP
-#define TAO_JSON_MSGPACK_TO_STRING_HPP
-
-#include <string>
-
-#include "../value.hpp"
-
-#include "../events/from_value.hpp"
-#include "../events/transformer.hpp"
-
-#include "events/to_string.hpp"
-
-namespace tao::json::msgpack
-{
-   template< template< typename... > class... Transformers, template< typename... > class Traits >
-   [[nodiscard]] std::string to_string( const basic_value< Traits >& v )
-   {
-      json::events::transformer< events::to_string, Transformers... > consumer;
-      json::events::from_value( consumer, v );
-      return consumer.value();
-   }
-
-}  // namespace tao::json::msgpack
-
-#endif

data/ext/third_party/json/include/tao/json/operators.hpp

@@ -1,490 +0,0 @@
-// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#ifndef TAO_JSON_OPERATORS_HPP
-#define TAO_JSON_OPERATORS_HPP
-
-#include "basic_value.hpp"
-
-#include "internal/format.hpp"
-
-namespace tao::json
-{
-   template< template< typename... > class TraitsL, template< typename... > class TraitsR >
-   [[nodiscard]] bool operator==( const basic_value< TraitsL >& lhs, const basic_value< TraitsR >& rhs ) noexcept
-   {
-      if( rhs.is_value_ptr() ) {
-         return lhs == rhs.skip_value_ptr();
-      }
-      if( lhs.type() != rhs.type() ) {
-         switch( lhs.type() ) {
-            case type::VALUE_PTR:
-               return lhs.skip_value_ptr() == rhs;
-
-            case type::SIGNED:
-               if( rhs.type() == type::UNSIGNED ) {
-                  const auto v = lhs.get_signed();
-                  return ( v >= 0 ) && ( static_cast< std::uint64_t >( v ) == rhs.get_unsigned() );
-               }
-               if( rhs.type() == type::DOUBLE ) {
-                  return lhs.get_signed() == rhs.get_double();
-               }
-               break;
-
-            case type::UNSIGNED:
-               if( rhs.type() == type::SIGNED ) {
-                  const auto v = rhs.get_signed();
-                  return ( v >= 0 ) && ( lhs.get_unsigned() == static_cast< std::uint64_t >( v ) );
-               }
-               if( rhs.type() == type::DOUBLE ) {
-                  return lhs.get_unsigned() == rhs.get_double();
-               }
-               break;
-
-            case type::DOUBLE:
-               if( rhs.type() == type::SIGNED ) {
-                  return lhs.get_double() == rhs.get_signed();
-               }
-               if( rhs.type() == type::UNSIGNED ) {
-                  return lhs.get_double() == rhs.get_unsigned();
-               }
-               break;
-
-            case type::STRING:
-               if( rhs.type() == type::STRING_VIEW ) {
-                  return lhs.get_string() == rhs.get_string_view();
-               }
-               break;
-
-            case type::STRING_VIEW:
-               if( rhs.type() == type::STRING ) {
-                  return lhs.get_string_view() == rhs.get_string();
-               }
-               break;
-
-            case type::BINARY:
-               if( rhs.type() == type::BINARY_VIEW ) {
-                  return tao::internal::binary_equal( lhs.get_binary(), rhs.get_binary_view() );
-               }
-               break;
-
-            case type::BINARY_VIEW:
-               if( rhs.type() == type::BINARY ) {
-                  return tao::internal::binary_equal( lhs.get_binary_view(), rhs.get_binary() );
-               }
-               break;
-
-            case type::OPAQUE_PTR:
-               assert( lhs.type() != type::OPAQUE_PTR );
-               break;
-
-            default:
-               break;
-         }
-         assert( rhs.type() != type::OPAQUE_PTR );
-         return false;
-      }
-
-      switch( lhs.type() ) {
-         case type::UNINITIALIZED:
-         case type::NULL_:
-            return true;
-
-         case type::BOOLEAN:
-            return lhs.get_boolean() == rhs.get_boolean();
-
-         case type::SIGNED:
-            return lhs.get_signed() == rhs.get_signed();
-
-         case type::UNSIGNED:
-            return lhs.get_unsigned() == rhs.get_unsigned();
-
-         case type::DOUBLE:
-            return lhs.get_double() == rhs.get_double();
-
-         case type::STRING:
-            return lhs.get_string() == rhs.get_string();
-
-         case type::STRING_VIEW:
-            return lhs.get_string_view() == rhs.get_string_view();
-
-         case type::BINARY:
-            return lhs.get_binary() == rhs.get_binary();
-
-         case type::BINARY_VIEW:
-            return tao::internal::binary_equal( lhs.get_binary_view(), rhs.get_binary_view() );
-
-         case type::ARRAY:
-            return lhs.get_array() == rhs.get_array();
-
-         case type::OBJECT:
-            return lhs.get_object() == rhs.get_object();
-
-         case type::VALUE_PTR:
-            assert( lhs.type() != type::VALUE_PTR );
-            break;  // LCOV_EXCL_LINE
-
-         case type::OPAQUE_PTR:
-            assert( lhs.type() != type::OPAQUE_PTR );
-            break;  // LCOV_EXCL_LINE
-
-         case type::VALUELESS_BY_EXCEPTION:
-            assert( lhs.type() != type::VALUELESS_BY_EXCEPTION );
-            break;  // LCOV_EXCL_LINE
-      }
-      // LCOV_EXCL_START
-      assert( false );
-      return false;
-      // LCOV_EXCL_STOP
-   }
-
-   template< template< typename... > class Traits, int = 1 >  // work-around for Visual C++
-   [[nodiscard]] bool operator==( const basic_value< Traits >& lhs, tao::internal::identity_t< basic_value< Traits > > rhs ) noexcept
-   {
-      return lhs == rhs;
-   }
-
-   template< template< typename... > class Traits, int = 2 >  // work-around for Visual C++
-   [[nodiscard]] bool operator==( tao::internal::identity_t< basic_value< Traits > > lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return lhs == rhs;
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] bool operator==( const basic_value< Traits >& lhs, const std::optional< T >& rhs ) noexcept
-   {
-      static_assert( noexcept( Traits< std::optional< T > >::equal( lhs, rhs ) ), "equal must be noexcept" );
-      return Traits< std::optional< T > >::equal( lhs, rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] bool operator==( const std::optional< T >& lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return rhs == lhs;
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] auto operator==( const basic_value< Traits >& lhs, const T& rhs ) noexcept -> decltype( Traits< std::decay_t< T > >::equal( lhs, rhs ) )
-   {
-      using D = std::decay_t< T >;
-      static_assert( noexcept( Traits< D >::equal( lhs, rhs ) ), "equal must be noexcept" );
-      return Traits< D >::equal( lhs, rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] auto operator==( const T& lhs, const basic_value< Traits >& rhs ) noexcept -> decltype( Traits< std::decay_t< T > >::equal( rhs, lhs ) )
-   {
-      return rhs == lhs;
-   }
-
-   template< template< typename... > class TraitsL, template< typename... > class TraitsR >
-   [[nodiscard]] bool operator!=( const basic_value< TraitsL >& lhs, const basic_value< TraitsR >& rhs ) noexcept
-   {
-      return !( lhs == rhs );
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] bool operator!=( const basic_value< Traits >& lhs, const std::optional< T >& rhs ) noexcept
-   {
-      return !( lhs == rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] bool operator!=( const std::optional< T >& lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return !( rhs == lhs );
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] bool operator!=( const basic_value< Traits >& lhs, const T& rhs ) noexcept
-   {
-      return !( lhs == rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] bool operator!=( const T& lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return !( lhs == rhs );
-   }
-
-   template< template< typename... > class TraitsL, template< typename... > class TraitsR >
-   [[nodiscard]] bool operator<( const basic_value< TraitsL >& lhs, const basic_value< TraitsR >& rhs ) noexcept
-   {
-      if( rhs.is_value_ptr() ) {
-         return lhs < rhs.skip_value_ptr();
-      }
-      if( lhs.type() != rhs.type() ) {
-         switch( lhs.type() ) {
-            case type::VALUE_PTR:
-               return lhs.skip_value_ptr() < rhs;
-
-            case type::SIGNED:
-               if( rhs.type() == type::UNSIGNED ) {
-                  const auto v = lhs.get_signed();
-                  return ( v < 0 ) || ( static_cast< std::uint64_t >( v ) < rhs.get_unsigned() );
-               }
-               if( rhs.type() == type::DOUBLE ) {
-                  return lhs.get_signed() < rhs.get_double();
-               }
-               break;
-
-            case type::UNSIGNED:
-               if( rhs.type() == type::SIGNED ) {
-                  const auto v = rhs.get_signed();
-                  return ( v >= 0 ) && ( lhs.get_unsigned() < static_cast< std::uint64_t >( v ) );
-               }
-               if( rhs.type() == type::DOUBLE ) {
-                  return lhs.get_unsigned() < rhs.get_double();
-               }
-               break;
-
-            case type::DOUBLE:
-               if( rhs.type() == type::SIGNED ) {
-                  return lhs.get_double() < rhs.get_signed();
-               }
-               if( rhs.type() == type::UNSIGNED ) {
-                  return lhs.get_double() < rhs.get_unsigned();
-               }
-               break;
-
-            case type::STRING:
-               if( rhs.type() == type::STRING_VIEW ) {
-                  return lhs.get_string() < rhs.get_string_view();
-               }
-               break;
-
-            case type::STRING_VIEW:
-               if( rhs.type() == type::STRING ) {
-                  return lhs.get_string_view() < rhs.get_string();
-               }
-               break;
-
-            case type::BINARY:
-               if( rhs.type() == type::BINARY_VIEW ) {
-                  return tao::internal::binary_less( lhs.get_binary(), rhs.get_binary_view() );
-               }
-               break;
-
-            case type::BINARY_VIEW:
-               if( rhs.type() == type::BINARY ) {
-                  return tao::internal::binary_less( lhs.get_binary_view(), rhs.get_binary() );
-               }
-               break;
-
-            case type::OPAQUE_PTR:
-               assert( lhs.type() != type::OPAQUE_PTR );
-               break;
-
-            default:
-               break;
-         }
-         assert( rhs.type() != type::OPAQUE_PTR );
-         return lhs.type() < rhs.type();
-      }
-
-      switch( lhs.type() ) {
-         case type::UNINITIALIZED:
-         case type::NULL_:
-            return false;
-
-         case type::BOOLEAN:
-            return lhs.get_boolean() < rhs.get_boolean();
-
-         case type::SIGNED:
-            return lhs.get_signed() < rhs.get_signed();
-
-         case type::UNSIGNED:
-            return lhs.get_unsigned() < rhs.get_unsigned();
-
-         case type::DOUBLE:
-            return lhs.get_double() < rhs.get_double();
-
-         case type::STRING:
-            return lhs.get_string() < rhs.get_string();
-
-         case type::STRING_VIEW:
-            return lhs.get_string_view() < rhs.get_string_view();
-
-         case type::BINARY:
-            return lhs.get_binary() < rhs.get_binary();
-
-         case type::BINARY_VIEW:
-            return tao::internal::binary_less( lhs.get_binary_view(), rhs.get_binary_view() );
-
-         case type::ARRAY:
-            return lhs.get_array() < rhs.get_array();
-
-         case type::OBJECT:
-            return lhs.get_object() < rhs.get_object();
-
-         case type::VALUE_PTR:
-            assert( lhs.type() != type::VALUE_PTR );
-            break;  // LCOV_EXCL_LINE
-
-         case type::OPAQUE_PTR:
-            assert( lhs.type() != type::OPAQUE_PTR );
-            break;  // LCOV_EXCL_LINE
-
-         case type::VALUELESS_BY_EXCEPTION:
-            assert( lhs.type() != type::VALUELESS_BY_EXCEPTION );
-            break;  // LCOV_EXCL_LINE
-      }
-      // LCOV_EXCL_START
-      assert( false );
-      return false;
-      // LCOV_EXCL_STOP
-   }
-
-   template< template< typename... > class Traits, int = 1 >  // work-around for Visual C++
-   [[nodiscard]] bool operator<( const basic_value< Traits >& lhs, tao::internal::identity_t< basic_value< Traits > > rhs ) noexcept
-   {
-      return lhs < rhs;
-   }
-
-   template< template< typename... > class Traits, int = 2 >  // work-around for Visual C++
-   [[nodiscard]] bool operator<( const tao::internal::identity_t< basic_value< Traits > > lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return lhs < rhs;
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] bool operator<( const basic_value< Traits >& lhs, const std::optional< T >& rhs ) noexcept
-   {
-      static_assert( noexcept( Traits< std::optional< T > >::less_than( lhs, rhs ) ), "less_than must be noexcept" );
-      return Traits< std::optional< T > >::less_than( lhs, rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] bool operator<( const std::optional< T >& lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      static_assert( noexcept( Traits< std::optional< T > >::greater_than( rhs, lhs ) ), "greater_than must be noexcept" );
-      return Traits< std::optional< T > >::greater_than( rhs, lhs );
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] auto operator<( const basic_value< Traits >& lhs, const T& rhs ) noexcept -> decltype( Traits< std::decay_t< T > >::less_than( lhs, rhs ) )
-   {
-      using D = std::decay_t< T >;
-      static_assert( noexcept( Traits< D >::less_than( lhs, rhs ) ), "less_than must be noexcept" );
-      return Traits< D >::less_than( lhs, rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] auto operator<( const T& lhs, const basic_value< Traits >& rhs ) noexcept -> decltype( Traits< std::decay_t< T > >::greater_than( rhs, lhs ) )
-   {
-      using D = std::decay_t< T >;
-      static_assert( noexcept( Traits< D >::greater_than( rhs, lhs ) ), "greater_than must be noexcept" );
-      return Traits< D >::greater_than( rhs, lhs );
-   }
-
-   template< template< typename... > class TraitsL, template< typename... > class TraitsR >
-   [[nodiscard]] bool operator>( const basic_value< TraitsL >& lhs, const basic_value< TraitsR >& rhs ) noexcept
-   {
-      return rhs < lhs;
-   }
-
-   template< template< typename... > class Traits >
-   [[nodiscard]] bool operator>( const basic_value< Traits >& lhs, tao::internal::identity_t< basic_value< Traits > > rhs ) noexcept
-   {
-      return rhs < lhs;
-   }
-
-   template< template< typename... > class Traits >
-   [[nodiscard]] bool operator>( tao::internal::identity_t< basic_value< Traits > > lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return rhs < lhs;
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] bool operator>( const basic_value< Traits >& lhs, const std::optional< T >& rhs ) noexcept
-   {
-      static_assert( noexcept( Traits< std::optional< T > >::greater_than( lhs, rhs ) ), "greater_than must be noexcept" );
-      return Traits< std::optional< T > >::greater_than( lhs, rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] bool operator>( const std::optional< T >& lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      static_assert( noexcept( Traits< std::optional< T > >::less_than( rhs, lhs ) ), "less_than must be noexcept" );
-      return Traits< std::optional< T > >::less_than( rhs, lhs );
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] auto operator>( const basic_value< Traits >& lhs, const T& rhs ) noexcept -> decltype( Traits< std::decay_t< T > >::greater_than( lhs, rhs ) )
-   {
-      using D = std::decay_t< T >;
-      static_assert( noexcept( Traits< D >::greater_than( lhs, rhs ) ), "greater_than must be noexcept" );
-      return Traits< D >::greater_than( lhs, rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] auto operator>( const T& lhs, const basic_value< Traits >& rhs ) noexcept -> decltype( Traits< std::decay_t< T > >::less_than( rhs, lhs ) )
-   {
-      using D = std::decay_t< T >;
-      static_assert( noexcept( Traits< D >::less_than( rhs, lhs ) ), "less_than must be noexcept" );
-      return Traits< D >::less_than( rhs, lhs );
-   }
-
-   template< template< typename... > class TraitsL, template< typename... > class TraitsR >
-   [[nodiscard]] bool operator<=( const basic_value< TraitsL >& lhs, const basic_value< TraitsR >& rhs ) noexcept
-   {
-      return !( lhs > rhs );
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] bool operator<=( const basic_value< Traits >& lhs, const std::optional< T >& rhs ) noexcept
-   {
-      return !( lhs > rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] bool operator<=( const std::optional< T >& lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return !( lhs > rhs );
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] bool operator<=( const basic_value< Traits >& lhs, const T& rhs ) noexcept
-   {
-      return !( lhs > rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] bool operator<=( const T& lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return !( lhs > rhs );
-   }
-
-   template< template< typename... > class TraitsL, template< typename... > class TraitsR >
-   [[nodiscard]] bool operator>=( const basic_value< TraitsL >& lhs, const basic_value< TraitsR >& rhs ) noexcept
-   {
-      return !( lhs < rhs );
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] bool operator>=( const basic_value< Traits >& lhs, const std::optional< T >& rhs ) noexcept
-   {
-      return !( lhs < rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] bool operator>=( const std::optional< T >& lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return !( lhs < rhs );
-   }
-
-   template< template< typename... > class Traits, typename T >
-   [[nodiscard]] bool operator>=( const basic_value< Traits >& lhs, const T& rhs ) noexcept
-   {
-      return !( lhs < rhs );
-   }
-
-   template< typename T, template< typename... > class Traits >
-   [[nodiscard]] bool operator>=( const T& lhs, const basic_value< Traits >& rhs ) noexcept
-   {
-      return !( lhs < rhs );
-   }
-
-}  // namespace tao::json
-
-#endif