RubyGems - couchbase - Versions diffs - 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19 - Mend

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

Files changed (1318) hide show

data/ext/third_party/json/include/tao/json/events/to_stream.hpp DELETED

@@ -1,142 +0,0 @@
-// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-#ifndef TAO_JSON_EVENTS_TO_STREAM_HPP
-#define TAO_JSON_EVENTS_TO_STREAM_HPP
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <ostream>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include "../binary_view.hpp"
-#include "../external/itoa.hpp"
-#include "../external/ryu.hpp"
-#include "../internal/escape.hpp"
-namespace tao::json::events
-{
-   // Events consumer to build a JSON string representation.
-   class to_stream
-   {
-   protected:
-      std::ostream& os;
-      bool first;
-      void next()
-      {
-         if( !first ) {
-            os.put( ',' );
-         }
-      }
-   public:
-      explicit to_stream( std::ostream& in_os ) noexcept
-         : os( in_os ),
-           first( true )
-      {}
-      void null()
-      {
-         next();
-         os.write( "null", 4 );
-      }
-      void boolean( const bool v )
-      {
-         next();
-         if( v ) {
-            os.write( "true", 4 );
-         }
-         else {
-            os.write( "false", 5 );
-         }
-      }
-      void number( const std::int64_t v )
-      {
-         next();
-         itoa::i64tos( os, v );
-      }
-      void number( const std::uint64_t v )
-      {
-         next();
-         itoa::u64tos( os, v );
-      }
-      void number( const double v )
-      {
-         next();
-         if( !std::isfinite( v ) ) {
-            // if this throws, consider using non_finite_to_* transformers
-            throw std::runtime_error( "non-finite double value invalid for JSON string representation" );
-         }
-         ryu::d2s_stream( os, v );
-      }
-      void string( const std::string_view v )
-      {
-         next();
-         os.put( '"' );
-         internal::escape( os, v );
-         os.put( '"' );
-      }
-      void binary( const tao::binary_view /*unused*/ )  // NOLINT(readability-convert-member-functions-to-static)
-      {
-         // if this throws, consider using binary_to_* transformers
-         throw std::runtime_error( "binary data invalid for JSON string representation" );
-      }
-      void begin_array( const std::size_t /*unused*/ = 0 )
-      {
-         next();
-         os.put( '[' );
-         first = true;
-      }
-      void element() noexcept
-      {
-         first = false;
-      }
-      void end_array( const std::size_t /*unused*/ = 0 )
-      {
-         os.put( ']' );
-      }
-      void begin_object( const std::size_t /*unused*/ = 0 )
-      {
-         next();
-         os.put( '{' );
-         first = true;
-      }
-      void key( const std::string_view v )
-      {
-         string( v );
-         os.put( ':' );
-         first = true;
-      }
-      void member() noexcept
-      {
-         first = false;
-      }
-      void end_object( const std::size_t /*unused*/ = 0 )
-      {
-         os.put( '}' );
-      }
-   };
-}  // namespace tao::json::events
-#endif

data/ext/third_party/json/include/tao/json/events/to_string.hpp DELETED

@@ -1,33 +0,0 @@
-// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-#ifndef TAO_JSON_EVENTS_TO_STRING_HPP
-#define TAO_JSON_EVENTS_TO_STRING_HPP
-#include <sstream>
-#include <string>
-#include "to_stream.hpp"
-namespace tao::json::events
-{
-   // Events consumer to build a JSON string representation.
-   struct to_string
-      : to_stream
-   {
-      std::ostringstream oss;
-      to_string()
-         : to_stream( oss )
-      {}
-      [[nodiscard]] std::string value() const
-      {
-         return oss.str();
-      }
-   };
-}  // namespace tao::json::events
-#endif

data/ext/third_party/json/include/tao/json/events/to_value.hpp DELETED

@@ -1,137 +0,0 @@
-// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-#ifndef TAO_JSON_EVENTS_TO_VALUE_HPP
-#define TAO_JSON_EVENTS_TO_VALUE_HPP
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-#include "../binary_view.hpp"
-#include "../value.hpp"
-namespace tao::json::events
-{
-   // Events consumer to build a JSON Value.
-   template< template< typename... > class Traits >
-   struct to_basic_value
-   {
-      std::vector< basic_value< Traits > > stack_;
-      std::vector< std::string > keys_;
-      basic_value< Traits > value;
-      void null()
-      {
-         value.set_null();
-      }
-      void boolean( const bool v )
-      {
-         value.set_boolean( v );
-      }
-      void number( const std::int64_t v )
-      {
-         value.set_signed( v );
-      }
-      void number( const std::uint64_t v )
-      {
-         value.set_unsigned( v );
-      }
-      void number( const double v )
-      {
-         value.set_double( v );
-      }
-      void string( const std::string_view v )
-      {
-         value.emplace_string( v );
-      }
-      void string( const char* v )
-      {
-         value.emplace_string( v );
-      }
-      void string( std::string&& v )
-      {
-         value.emplace_string( std::move( v ) );
-      }
-      void binary( const tao::binary_view v )
-      {
-         value.emplace_binary( v.begin(), v.end() );
-      }
-      void binary( std::vector< std::byte >&& v )
-      {
-         value.emplace_binary( std::move( v ) );
-      }
-      void begin_array()
-      {
-         stack_.emplace_back( empty_array );
-      }
-      void begin_array( const std::size_t size )
-      {
-         begin_array();
-         stack_.back().get_array().reserve( size );
-      }
-      void element()
-      {
-         stack_.back().emplace_back( std::move( value ) );
-      }
-      void end_array( const std::size_t /*unused*/ = 0 )
-      {
-         value = std::move( stack_.back() );
-         stack_.pop_back();
-      }
-      void begin_object( const std::size_t /*unused*/ = 0 )
-      {
-         stack_.emplace_back( empty_object );
-      }
-      void key( const std::string_view v )
-      {
-         keys_.emplace_back( v );
-      }
-      void key( const char* v )
-      {
-         keys_.emplace_back( v );
-      }
-      void key( std::string&& v )
-      {
-         keys_.emplace_back( std::move( v ) );
-      }
-      void member()
-      {
-         stack_.back().try_emplace( std::move( keys_.back() ), std::move( value ) );
-         keys_.pop_back();
-      }
-      void end_object( const std::size_t /*unused*/ = 0 )
-      {
-         value = std::move( stack_.back() );
-         stack_.pop_back();
-      }
-   };
-   using to_value = to_basic_value< traits >;
-}  // namespace tao::json::events
-#endif

data/ext/third_party/json/include/tao/json/events/transformer.hpp DELETED

@@ -1,70 +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_EVENTS_TRANSFORMER_HPP
-#define TAO_JSON_EVENTS_TRANSFORMER_HPP
-#include <utility>
-#include "../internal/dependent_false.hpp"
-namespace tao::json
-{
-   namespace internal
-   {
-      template< template< typename... > class T >
-      struct invalid_transformer
-      {
-         // if this static assert is triggered there is a high chance that 'T' is
-         // a traits class template and you intended to call a method starting with "basic_*",
-         // e.g. basic_from_file< my_traits >( ... ) instead of from_file< my_traits >( ... ).
-         static_assert( internal::dependent_false< invalid_transformer< T > >, "T is not a valid transformer" );
-      };
-      template< typename B, template< typename... > class T, typename = void >
-      struct check_transformer
-         : invalid_transformer< T >
-      {
-         using type = B;
-      };
-      template< typename B, template< typename... > class T >
-      struct check_transformer< B,
-                                T,
-                                decltype( std::declval< T< B > >().null(),
-                                          std::declval< T< B > >().boolean( true ),
-                                          std::declval< T< B > >().number( double( 0.0 ) ),
-                                          std::declval< T< B > >().string( "" ),
-                                          std::declval< T< B > >().element(),
-                                          std::declval< T< B > >().member(),
-                                          void() ) >
-      {
-         using type = T< B >;
-      };
-      template< typename Consumer, template< typename... > class... Transformer >
-      struct transformer;
-      template< typename Consumer >
-      struct transformer< Consumer >
-      {
-         using type = Consumer;
-      };
-      template< typename Consumer, template< typename... > class Head, template< typename... > class... Tail >
-      struct transformer< Consumer, Head, Tail... >
-         : check_transformer< typename transformer< Consumer, Tail... >::type, Head >
-      {};
-   }  // namespace internal
-   namespace events
-   {
-      template< typename Consumer, template< typename... > class... Transformer >
-      using transformer = typename internal::transformer< Consumer, Transformer... >::type;
-   }  // namespace events
-}  // namespace tao::json
-#endif

data/ext/third_party/json/include/tao/json/events/validate_event_order.hpp DELETED

@@ -1,411 +0,0 @@
-// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-#ifndef TAO_JSON_EVENTS_VALIDATE_EVENT_ORDER_HPP
-#define TAO_JSON_EVENTS_VALIDATE_EVENT_ORDER_HPP
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <optional>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <vector>
-#include "../binary_view.hpp"
-namespace tao::json::events
-{
-   // Events consumer that validates the order of events.
-   class validate_event_order
-   {
-   private:
-      enum state_t
-      {
-         EXPECT_TOP_LEVEL_VALUE,
-         EXPECT_ARRAY_VALUE_OR_END,
-         EXPECT_ARRAY_ELEMENT,
-         EXPECT_SIZED_ARRAY_VALUE_OR_END,
-         EXPECT_SIZED_ARRAY_ELEMENT,
-         EXPECT_OBJECT_KEY_OR_END,
-         EXPECT_OBJECT_VALUE,
-         EXPECT_OBJECT_MEMBER,
-         EXPECT_SIZED_OBJECT_KEY_OR_END,
-         EXPECT_SIZED_OBJECT_VALUE,
-         EXPECT_SIZED_OBJECT_MEMBER,
-         EXPECT_NOTHING
-      };
-      struct sizes_t
-      {
-         explicit sizes_t( const std::size_t in_expected )
-            : expected( in_expected )
-         {}
-         void check( const std::size_t in_expected ) const
-         {
-            if( expected != in_expected ) {
-               throw std::logic_error( "inconsistent size" );
-            }
-            if( expected != counted ) {
-               throw std::logic_error( "wrong size" );
-            }
-         }
-         std::size_t expected;
-         std::size_t counted = 0;
-      };
-      state_t state = EXPECT_TOP_LEVEL_VALUE;
-      std::vector< state_t > stack;
-      std::vector< sizes_t > sizes;
-      void atom( const std::string& function )
-      {
-         switch( state ) {
-            case EXPECT_TOP_LEVEL_VALUE:
-               state = EXPECT_NOTHING;
-               return;
-            case EXPECT_ARRAY_VALUE_OR_END:
-               state = EXPECT_ARRAY_ELEMENT;
-               return;
-            case EXPECT_SIZED_ARRAY_VALUE_OR_END:
-               state = EXPECT_SIZED_ARRAY_ELEMENT;
-               return;
-            case EXPECT_ARRAY_ELEMENT:
-            case EXPECT_SIZED_ARRAY_ELEMENT:
-               throw std::logic_error( "expected element(), but " + function + " was called" );
-            case EXPECT_OBJECT_KEY_OR_END:
-            case EXPECT_SIZED_OBJECT_KEY_OR_END:
-               throw std::logic_error( "expected key() or end_object(...), but " + function + " was called" );
-            case EXPECT_OBJECT_VALUE:
-               state = EXPECT_OBJECT_MEMBER;
-               return;
-            case EXPECT_SIZED_OBJECT_VALUE:
-               state = EXPECT_SIZED_OBJECT_MEMBER;
-               return;
-            case EXPECT_OBJECT_MEMBER:
-            case EXPECT_SIZED_OBJECT_MEMBER:
-               throw std::logic_error( "expected member(), but " + function + " was called" );
-            case EXPECT_NOTHING:
-               throw std::logic_error( "expected nothing, but " + function + " was called" );
-         }
-         throw std::logic_error( "invalid state" );
-      }
-   public:
-      [[nodiscard]] bool is_complete() const noexcept
-      {
-         return state == EXPECT_NOTHING;
-      }
-      void null()
-      {
-         atom( "null()" );
-      }
-      void boolean( const bool /*unused*/ )
-      {
-         atom( "boolen()" );
-      }
-      void number( const std::int64_t /*unused*/ )
-      {
-         atom( "number(std::int64_t)" );
-      }
-      void number( const std::uint64_t /*unused*/ )
-      {
-         atom( "number(std::uint64_t)" );
-      }
-      void number( const double /*unused*/ )
-      {
-         atom( "number(double)" );
-      }
-      void string( const std::string_view /*unused*/ )
-      {
-         atom( "string(...)" );
-      }
-      void binary( const tao::binary_view /*unused*/ )
-      {
-         atom( "binary(...)" );
-      }
-      void begin_array()
-      {
-         switch( state ) {
-            case EXPECT_TOP_LEVEL_VALUE:
-               stack.push_back( EXPECT_NOTHING );
-               state = EXPECT_ARRAY_VALUE_OR_END;
-               return;
-            case EXPECT_ARRAY_VALUE_OR_END:
-               stack.push_back( EXPECT_ARRAY_ELEMENT );
-               return;
-            case EXPECT_SIZED_ARRAY_VALUE_OR_END:
-               stack.push_back( EXPECT_SIZED_ARRAY_ELEMENT );
-               return;
-            case EXPECT_ARRAY_ELEMENT:
-            case EXPECT_SIZED_ARRAY_ELEMENT:
-               throw std::logic_error( "expected element(), but begin_array(...) was called" );
-            case EXPECT_OBJECT_KEY_OR_END:
-            case EXPECT_SIZED_OBJECT_KEY_OR_END:
-               throw std::logic_error( "expected key() or end_object(...), but begin_array(...) was called" );
-            case EXPECT_OBJECT_VALUE:
-               stack.push_back( EXPECT_OBJECT_MEMBER );
-               state = EXPECT_ARRAY_VALUE_OR_END;
-               return;
-            case EXPECT_SIZED_OBJECT_VALUE:
-               stack.push_back( EXPECT_SIZED_OBJECT_MEMBER );
-               state = EXPECT_ARRAY_VALUE_OR_END;
-               return;
-            case EXPECT_OBJECT_MEMBER:
-            case EXPECT_SIZED_OBJECT_MEMBER:
-               throw std::logic_error( "expected member(), but begin_array(...) was called" );
-            case EXPECT_NOTHING:
-               throw std::logic_error( "expected nothing, but begin_array(...) was called" );
-         }
-         throw std::logic_error( "invalid state" );
-      }
-      void begin_array( const std::size_t expected )
-      {
-         begin_array();
-         sizes.emplace_back( expected );
-         state = EXPECT_SIZED_ARRAY_VALUE_OR_END;
-      }
-      void element()
-      {
-         switch( state ) {
-            case EXPECT_TOP_LEVEL_VALUE:
-               throw std::logic_error( "expected any value, but element() was called" );
-            case EXPECT_ARRAY_VALUE_OR_END:
-            case EXPECT_SIZED_ARRAY_VALUE_OR_END:
-               throw std::logic_error( "expected any value or end_array(...), but element() was called" );
-            case EXPECT_ARRAY_ELEMENT:
-               state = EXPECT_ARRAY_VALUE_OR_END;
-               return;
-            case EXPECT_SIZED_ARRAY_ELEMENT:
-               state = EXPECT_SIZED_ARRAY_VALUE_OR_END;
-               ++sizes.back().counted;
-               return;
-            case EXPECT_OBJECT_KEY_OR_END:
-            case EXPECT_SIZED_OBJECT_KEY_OR_END:
-               throw std::logic_error( "expected key() or end_object(...), but element() was called" );
-            case EXPECT_OBJECT_VALUE:
-            case EXPECT_SIZED_OBJECT_VALUE:
-               throw std::logic_error( "expected any value, but element() was called" );
-            case EXPECT_OBJECT_MEMBER:
-            case EXPECT_SIZED_OBJECT_MEMBER:
-               throw std::logic_error( "expected member(), but element() was called" );
-            case EXPECT_NOTHING:
-               throw std::logic_error( "expected nothing, but element() was called" );
-         }
-         throw std::logic_error( "invalid state" );
-      }
-      void end_array()
-      {
-         switch( state ) {
-            case EXPECT_TOP_LEVEL_VALUE:
-               throw std::logic_error( "expected any value, but end_array(....) was called" );
-            case EXPECT_ARRAY_VALUE_OR_END:
-               state = stack.back();
-               stack.pop_back();
-               return;
-            case EXPECT_SIZED_ARRAY_VALUE_OR_END:
-               throw std::logic_error( "expected end_array(std::size_t), but end_array() was called" );
-            case EXPECT_ARRAY_ELEMENT:
-            case EXPECT_SIZED_ARRAY_ELEMENT:
-               throw std::logic_error( "expected element(), but end_array(...) was called" );
-            case EXPECT_OBJECT_KEY_OR_END:
-            case EXPECT_SIZED_OBJECT_KEY_OR_END:
-               throw std::logic_error( "expected key() or end_object(...), but end_array(...) was called" );
-            case EXPECT_OBJECT_VALUE:
-            case EXPECT_SIZED_OBJECT_VALUE:
-               throw std::logic_error( "expected any value, but end_array(...) was called" );
-            case EXPECT_OBJECT_MEMBER:
-            case EXPECT_SIZED_OBJECT_MEMBER:
-               throw std::logic_error( "expected member(), but end_array(...) was called" );
-            case EXPECT_NOTHING:
-               throw std::logic_error( "expected nothing, but end_array(...) was called" );
-         }
-         throw std::logic_error( "invalid state" );
-      }
-      void end_array( const std::size_t expected )
-      {
-         switch( state ) {
-            case EXPECT_SIZED_ARRAY_VALUE_OR_END:
-               state = EXPECT_ARRAY_VALUE_OR_END;
-               break;
-            case EXPECT_ARRAY_VALUE_OR_END:
-               throw std::logic_error( "expected any value or end_array(), but end_array(std::size_t) was called" );
-            default:
-               break;
-         }
-         assert( !sizes.empty() );
-         sizes.back().check( expected );
-         sizes.pop_back();
-         end_array();
-      }
-      void begin_object()
-      {
-         switch( state ) {
-            case EXPECT_TOP_LEVEL_VALUE:
-               stack.push_back( EXPECT_NOTHING );
-               state = EXPECT_OBJECT_KEY_OR_END;
-               return;
-            case EXPECT_ARRAY_VALUE_OR_END:
-               stack.push_back( EXPECT_ARRAY_ELEMENT );
-               state = EXPECT_OBJECT_KEY_OR_END;
-               return;
-            case EXPECT_SIZED_ARRAY_VALUE_OR_END:
-               stack.push_back( EXPECT_SIZED_ARRAY_ELEMENT );
-               state = EXPECT_OBJECT_KEY_OR_END;
-               return;
-            case EXPECT_ARRAY_ELEMENT:
-            case EXPECT_SIZED_ARRAY_ELEMENT:
-               throw std::logic_error( "expected element(), but begin_object(...) was called" );
-            case EXPECT_OBJECT_KEY_OR_END:
-            case EXPECT_SIZED_OBJECT_KEY_OR_END:
-               throw std::logic_error( "expected key() or end_object(...), but begin_object(...) was called" );
-            case EXPECT_OBJECT_VALUE:
-               stack.push_back( EXPECT_OBJECT_MEMBER );
-               state = EXPECT_OBJECT_KEY_OR_END;
-               return;
-            case EXPECT_SIZED_OBJECT_VALUE:
-               stack.push_back( EXPECT_SIZED_OBJECT_MEMBER );
-               state = EXPECT_OBJECT_KEY_OR_END;
-               return;
-            case EXPECT_OBJECT_MEMBER:
-            case EXPECT_SIZED_OBJECT_MEMBER:
-               throw std::logic_error( "expected member(), but begin_object(...) was called" );
-            case EXPECT_NOTHING:
-               throw std::logic_error( "expected nothing, but begin_object(...) was called" );
-         }
-         throw std::logic_error( "invalid state" );
-      }
-      void begin_object( const std::size_t expected )
-      {
-         begin_object();
-         sizes.emplace_back( expected );
-         state = EXPECT_SIZED_OBJECT_KEY_OR_END;
-      }
-      void key( const std::string_view /*unused*/ )
-      {
-         switch( state ) {
-            case EXPECT_TOP_LEVEL_VALUE:
-               throw std::logic_error( "expected any value, but key() was called" );
-            case EXPECT_ARRAY_VALUE_OR_END:
-            case EXPECT_SIZED_ARRAY_VALUE_OR_END:
-               throw std::logic_error( "expected any value or end_array(...), but key() was called" );
-            case EXPECT_ARRAY_ELEMENT:
-            case EXPECT_SIZED_ARRAY_ELEMENT:
-               throw std::logic_error( "expected element(), but key() was called" );
-            case EXPECT_OBJECT_KEY_OR_END:
-               state = EXPECT_OBJECT_VALUE;
-               return;
-            case EXPECT_SIZED_OBJECT_KEY_OR_END:
-               state = EXPECT_SIZED_OBJECT_VALUE;
-               return;
-            case EXPECT_OBJECT_VALUE:
-            case EXPECT_SIZED_OBJECT_VALUE:
-               throw std::logic_error( "expected any value, but key() was called" );
-            case EXPECT_OBJECT_MEMBER:
-            case EXPECT_SIZED_OBJECT_MEMBER:
-               throw std::logic_error( "expected member(), but key() was called" );
-            case EXPECT_NOTHING:
-               throw std::logic_error( "expected nothing, but key() was called" );
-         }
-         throw std::logic_error( "invalid state" );
-      }
-      void member()
-      {
-         switch( state ) {
-            case EXPECT_TOP_LEVEL_VALUE:
-               throw std::logic_error( "expected any value, but member() was called" );
-            case EXPECT_ARRAY_VALUE_OR_END:
-            case EXPECT_SIZED_ARRAY_VALUE_OR_END:
-               throw std::logic_error( "expected any value or end_array(...), but member() was called" );
-            case EXPECT_ARRAY_ELEMENT:
-            case EXPECT_SIZED_ARRAY_ELEMENT:
-               throw std::logic_error( "expected element(), but member() was called" );
-            case EXPECT_OBJECT_KEY_OR_END:
-            case EXPECT_SIZED_OBJECT_KEY_OR_END:
-               throw std::logic_error( "expected key() or end_object(...), but member() was called" );
-            case EXPECT_OBJECT_VALUE:
-            case EXPECT_SIZED_OBJECT_VALUE:
-               throw std::logic_error( "expected any value, but member() was called" );
-            case EXPECT_OBJECT_MEMBER:
-               state = EXPECT_OBJECT_KEY_OR_END;
-               return;
-            case EXPECT_SIZED_OBJECT_MEMBER:
-               state = EXPECT_SIZED_OBJECT_KEY_OR_END;
-               ++sizes.back().counted;
-               return;
-            case EXPECT_NOTHING:
-               throw std::logic_error( "expected nothing, but member() was called" );
-         }
-         throw std::logic_error( "invalid state" );
-      }
-      void end_object()
-      {
-         switch( state ) {
-            case EXPECT_TOP_LEVEL_VALUE:
-               throw std::logic_error( "expected any value, but end_object(...) was called" );
-            case EXPECT_ARRAY_VALUE_OR_END:
-            case EXPECT_SIZED_ARRAY_VALUE_OR_END:
-               throw std::logic_error( "expected any value or end_array(...), but end_object(...) was called" );
-            case EXPECT_ARRAY_ELEMENT:
-            case EXPECT_SIZED_ARRAY_ELEMENT:
-               throw std::logic_error( "expected element(), but end_object(...) was called" );
-            case EXPECT_OBJECT_KEY_OR_END:
-               state = stack.back();
-               stack.pop_back();
-               return;
-            case EXPECT_SIZED_OBJECT_KEY_OR_END:
-               throw std::logic_error( "expected any value or end_object(std::size_t), but end_object() was called" );
-            case EXPECT_OBJECT_VALUE:
-            case EXPECT_SIZED_OBJECT_VALUE:
-               throw std::logic_error( "expected any value, but end_object(...) was called" );
-            case EXPECT_OBJECT_MEMBER:
-            case EXPECT_SIZED_OBJECT_MEMBER:
-               throw std::logic_error( "expected member(), but end_object(...) was called" );
-            case EXPECT_NOTHING:
-               throw std::logic_error( "expected nothing, but end_object(...) was called" );
-         }
-         throw std::logic_error( "invalid state" );
-      }
-      void end_object( const std::size_t expected )
-      {
-         switch( state ) {
-            case EXPECT_SIZED_OBJECT_KEY_OR_END:
-               state = EXPECT_OBJECT_KEY_OR_END;
-               break;
-            case EXPECT_OBJECT_KEY_OR_END:
-               throw std::logic_error( "expected any value or end_object(), but end_object(std::size_t) was called" );
-            default:
-               break;
-         }
-         assert( !sizes.empty() );
-         sizes.back().check( expected );
-         sizes.pop_back();
-         end_object();
-      }
-   };
-}  // namespace tao::json::events
-#endif