couchbase 3.0.3-universal-darwin-20

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

@@ -0,0 +1,61 @@
+// 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_PRODUCE_HPP
+#define TAO_JSON_PRODUCE_HPP
+
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "forward.hpp"
+
+#include "events/produce.hpp"
+#include "events/to_pretty_stream.hpp"
+#include "events/to_stream.hpp"
+#include "events/to_string.hpp"
+#include "events/to_value.hpp"
+
+namespace tao::json::produce
+{
+   template< template< typename... > class Traits = traits, typename T >
+   [[nodiscard]] basic_value< Traits > to_value( T&& t )
+   {
+      events::to_basic_value< Traits > consumer;
+      events::produce< Traits >( consumer, std::forward< T >( t ) );
+      return std::move( consumer.value );
+   }
+
+   template< template< typename... > class Traits = traits, typename T >
+   void to_stream( std::ostream& os, const T& t )
+   {
+      events::to_stream consumer( os );
+      events::produce< Traits >( consumer, t );
+   }
+
+   template< template< typename... > class Traits = traits, typename T >
+   void to_stream( std::ostream& os, const T& t, const std::size_t indent )
+   {
+      events::to_pretty_stream consumer( os, indent );
+      events::produce< Traits >( consumer, t );
+   }
+
+   template< template< typename... > class Traits = traits, typename T, typename S >
+   void to_stream( std::ostream& os, const T& t, const std::size_t indent, S&& eol )
+   {
+      events::to_pretty_stream consumer( os, indent, std::forward< S >( eol ) );
+      events::produce< Traits >( consumer, t );
+   }
+
+   template< template< typename... > class Traits = traits, typename... Ts >
+   [[nodiscard]] std::string to_string( Ts&&... ts )
+   {
+      std::ostringstream oss;
+      to_stream< Traits >( oss, std::forward< Ts >( ts )... );
+      return oss.str();
+   }
+
+}  // namespace tao::json::produce
+
+#endif

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

@@ -0,0 +1,131 @@
+// 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_SELF_CONTAINED_HPP
+#define TAO_JSON_SELF_CONTAINED_HPP
+
+#include "events/to_value.hpp"
+#include "events/virtual_ref.hpp"
+
+#include "value.hpp"
+
+namespace tao::json
+{
+   // recursively checks for the existence
+   // of VALUE_PTR or OPAQUE_PTR nodes, STRING_VIEW or BINARY_VIEW,
+   // returns true is no such nodes were found.
+
+   template< template< typename... > class Traits >
+   [[nodiscard]] bool is_self_contained( const basic_value< Traits >& v ) noexcept
+   {
+      switch( v.type() ) {
+         case type::UNINITIALIZED:
+         case type::NULL_:
+         case type::BOOLEAN:
+         case type::SIGNED:
+         case type::UNSIGNED:
+         case type::DOUBLE:
+         case type::STRING:
+         case type::BINARY:
+         case type::VALUELESS_BY_EXCEPTION:
+            return true;
+
+         case type::STRING_VIEW:
+         case type::BINARY_VIEW:
+         case type::VALUE_PTR:
+         case type::OPAQUE_PTR:
+            return false;
+
+         case type::ARRAY:
+            for( const auto& e : v.get_array() ) {
+               if( !is_self_contained( e ) ) {
+                  return false;
+               }
+            }
+            return true;
+
+         case type::OBJECT:
+            for( const auto& e : v.get_object() ) {
+               if( !is_self_contained( e.second ) ) {
+                  return false;
+               }
+            }
+            return true;
+      }
+      // LCOV_EXCL_START
+      assert( false );
+      return false;
+      // LCOV_EXCL_STOP
+   }
+
+   // Removes all VALUE_PTR and OPAQUE_PTR nodes,
+   // recursively, by copying/generating their content;
+   // replaces STRING_VIEW and BINARY_VIEW with STRING
+   // and BINARY, respectively, with a copy of the data.
+
+   template< template< typename... > class Traits >
+   void make_self_contained( basic_value< Traits >& v )
+   {
+      switch( v.type() ) {
+         case type::UNINITIALIZED:
+         case type::NULL_:
+         case type::BOOLEAN:
+         case type::SIGNED:
+         case type::UNSIGNED:
+         case type::DOUBLE:
+         case type::STRING:
+         case type::BINARY:
+         case type::VALUELESS_BY_EXCEPTION:
+            return;
+
+         case type::STRING_VIEW:
+            v.emplace_string( v.get_string_view() );
+            return;
+
+         case type::BINARY_VIEW: {
+            const auto xv = v.get_binary_view();
+            v.emplace_binary( xv.begin(), xv.end() );
+            return;
+         }
+
+         case type::ARRAY:
+            for( auto& e : v.get_array() ) {
+               make_self_contained( e );
+            }
+            return;
+
+         case type::OBJECT:
+            for( auto& e : v.get_object() ) {
+               make_self_contained( e.second );
+            }
+            return;
+
+         case type::VALUE_PTR:
+            v = *v.get_value_ptr();
+            make_self_contained( v );
+            return;
+
+         case type::OPAQUE_PTR: {
+            const auto& q = v.get_opaque_ptr();
+            events::to_basic_value< Traits > consumer;
+            events::virtual_ref< events::to_basic_value< Traits > > ref( consumer );
+            q.producer( ref, q.data );
+            consumer.value.public_base() = std::move( v.public_base() );
+            v = std::move( consumer.value );
+            return;
+         }
+      }
+      throw std::logic_error( "invalid value for tao::json::type" );  // LCOV_EXCL_LINE
+   }
+
+   template< template< typename... > class Traits >
+   [[nodiscard]] basic_value< Traits > self_contained_copy( const basic_value< Traits >& v )
+   {
+      basic_value< Traits > r( &v );
+      make_self_contained( r );
+      return r;
+   }
+
+}  // namespace tao::json
+
+#endif

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

@@ -0,0 +1,496 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_SPAN_HPP
+#define TAO_JSON_SPAN_HPP
+
+#if !defined( TAO_JSON_USE_STD_SPAN ) && ( __cplusplus > 201703L ) && defined( __has_include )
+// clang-format off
+#if __has_include(<span>)
+// clang-format on
+#define TAO_JSON_USE_STD_SPAN
+#endif
+#endif
+
+#if defined( TAO_JSON_USE_STD_SPAN )
+
+#include <span>
+
+namespace tao
+{
+   using std::dynamic_extent;
+   using std::span;
+
+   using std::as_bytes;
+   using std::as_writable_bytes;
+
+}  // namespace tao
+
+#else
+
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <tuple>
+#include <type_traits>
+
+namespace tao
+{
+   inline constexpr std::size_t dynamic_extent = std::numeric_limits< std::size_t >::max();
+
+   template< typename ElementType, std::size_t Extent = dynamic_extent >
+   class span;
+
+   namespace internal
+   {
+      template< typename >
+      inline constexpr bool is_span = false;
+
+      template< typename ElementType, std::size_t Extent >
+      inline constexpr bool is_span< span< ElementType, Extent > > = true;
+
+      template< typename >
+      inline constexpr bool is_std_array = false;
+
+      template< typename T, std::size_t N >
+      inline constexpr bool is_std_array< std::array< T, N > > = true;
+
+      template< typename T, typename ElementType >
+      inline constexpr bool is_span_compatible_ptr = std::is_convertible_v< T ( * )[], ElementType ( * )[] >;
+
+      template< typename, typename, typename = void >
+      inline constexpr bool is_span_compatible_container = false;
+
+      template< typename Container, typename ElementType >
+      inline constexpr bool is_span_compatible_container< Container,
+                                                          ElementType,
+                                                          std::void_t<
+                                                             std::enable_if_t< !is_span< std::remove_cv_t< Container > > >,
+                                                             std::enable_if_t< !is_std_array< std::remove_cv_t< Container > > >,
+                                                             std::enable_if_t< !std::is_array_v< Container > >,
+                                                             decltype( std::data( std::declval< Container >() ) ),
+                                                             decltype( std::size( std::declval< Container >() ) ),
+                                                             std::enable_if_t< std::is_convertible_v< std::remove_pointer_t< decltype( std::data( std::declval< Container& >() ) ) > ( * )[], ElementType ( * )[] > > > > = true;
+
+   }  // namespace internal
+
+   template< typename ElementType, std::size_t Extent >
+   class span  // NOLINT(cppcoreguidelines-special-member-functions)
+   {
+   public:
+      static_assert( !std::is_abstract_v< ElementType > );
+
+      using element_type = ElementType;
+      using value_type = std::remove_cv_t< ElementType >;
+      using size_type = std::size_t;
+      using difference_type = std::ptrdiff_t;
+      using pointer = element_type*;
+      using const_pointer = const element_type*;
+      using reference = element_type&;
+      using const_reference = const element_type&;
+      using iterator = pointer;
+      using reverse_iterator = std::reverse_iterator< iterator >;
+
+      static constexpr size_type extent = Extent;
+
+      template< typename T = void, typename = std::enable_if_t< Extent == 0, T > >
+      constexpr span() noexcept
+         : m_data( nullptr )
+      {}
+
+      constexpr span( pointer ptr, size_type count ) noexcept
+         : m_data( ptr )
+      {
+         assert( count == Extent );
+      }
+
+      constexpr span( pointer first, pointer last ) noexcept
+         : m_data( first )
+      {
+         assert( std::distance( first, last ) == Extent );
+      }
+
+      constexpr span( element_type ( &arr )[ Extent ] ) noexcept
+         : m_data( arr )
+      {}
+
+      template< typename OtherElementType, std::size_t N, typename = std::enable_if_t< ( N == Extent ) && tao::internal::is_span_compatible_ptr< OtherElementType, ElementType > > >
+      constexpr span( std::array< OtherElementType, N >& arr ) noexcept
+         : m_data( static_cast< pointer >( arr.data() ) )
+      {}
+
+      template< typename OtherElementType, std::size_t N, typename = std::enable_if_t< ( N == Extent ) && tao::internal::is_span_compatible_ptr< const OtherElementType, ElementType > > >
+      constexpr span( const std::array< OtherElementType, N >& arr ) noexcept
+         : m_data( static_cast< pointer >( arr.data() ) )
+      {}
+
+      constexpr span( const span& ) = default;
+
+      template< typename OtherElementType, typename = std::enable_if_t< tao::internal::is_span_compatible_ptr< OtherElementType, ElementType > > >
+      constexpr span( const span< OtherElementType, Extent >& s ) noexcept
+         : m_data( s.data() )
+      {}
+
+      ~span() = default;
+
+      constexpr auto operator=( const span& ) -> span& = default;
+
+      constexpr auto size() const noexcept -> size_type  // NOLINT(modernize-use-nodiscard)
+      {
+         return Extent;
+      }
+
+      constexpr auto size_bytes() const noexcept -> size_type  // NOLINT(modernize-use-nodiscard)
+      {
+         return Extent * sizeof( element_type );
+      }
+
+      [[nodiscard]] constexpr auto empty() const noexcept -> bool
+      {
+         return Extent == 0;
+      }
+
+      constexpr auto operator[]( size_type idx ) const noexcept -> reference
+      {
+         assert( idx < Extent );
+         return *( data() + idx );
+      }
+
+      constexpr auto front() const noexcept -> reference
+      {
+         assert( Extent != 0 );
+         return *data();
+      }
+
+      constexpr auto back() const noexcept -> reference
+      {
+         assert( Extent != 0 );
+         return *( data() + ( Extent - 1 ) );
+      }
+
+      constexpr auto data() const noexcept -> pointer
+      {
+         return m_data;
+      }
+
+      constexpr auto begin() const noexcept -> iterator
+      {
+         return data();
+      }
+
+      constexpr auto end() const noexcept -> iterator
+      {
+         return data() + Extent;
+      }
+
+      constexpr auto rbegin() const noexcept -> reverse_iterator
+      {
+         return reverse_iterator( end() );
+      }
+
+      constexpr auto rend() const noexcept -> reverse_iterator
+      {
+         return reverse_iterator( begin() );
+      }
+
+      template< std::size_t Count >
+      constexpr auto first() const noexcept
+         -> span< element_type, Count >
+      {
+         static_assert( Count <= Extent );
+         return { data(), Count };
+      }
+
+      template< std::size_t Count >
+      constexpr auto last() const noexcept
+         -> span< element_type, Count >
+      {
+         static_assert( Count <= Extent );
+         return { data() + ( Extent - Count ), Count };
+      }
+
+      template< std::size_t Offset, std::size_t Count = dynamic_extent >
+      constexpr auto subspan() const
+         -> span< element_type, ( ( Count != dynamic_extent ) ? Count : ( Extent - Offset ) ) >
+      {
+         static_assert( Offset <= Extent );
+         static_assert( ( Count == dynamic_extent ) || ( Count <= ( Extent - Offset ) ) );
+         return { data() + Offset, ( Count != dynamic_extent ) ? Count : ( Extent - Offset ) };
+      }
+
+      constexpr auto first( size_type count ) const
+         -> span< element_type, dynamic_extent >
+      {
+         assert( count <= Extent );
+         return { data(), count };
+      }
+
+      constexpr auto last( size_type count ) const
+         -> span< element_type, dynamic_extent >
+      {
+         assert( count <= Extent );
+         return { data() + Extent - count, count };
+      }
+
+      constexpr auto subspan( size_type offset, size_type count = dynamic_extent ) const
+         -> span< element_type, dynamic_extent >
+      {
+         assert( offset <= Extent );
+         assert( ( count == dynamic_extent ) || ( count <= ( Extent - offset ) ) );
+         return { data() + offset, ( count != dynamic_extent ) ? count : ( Extent - offset ) };
+      }
+
+   private:
+      pointer m_data;
+   };
+
+   template< typename ElementType >
+   class span< ElementType, dynamic_extent >  // NOLINT(cppcoreguidelines-special-member-functions)
+   {
+   public:
+      static_assert( !std::is_abstract_v< ElementType > );
+
+      using element_type = ElementType;
+      using value_type = std::remove_cv_t< ElementType >;
+      using size_type = std::size_t;
+      using difference_type = std::ptrdiff_t;
+      using pointer = element_type*;
+      using const_pointer = const element_type*;
+      using reference = element_type&;
+      using const_reference = const element_type&;
+      using iterator = pointer;
+      using reverse_iterator = std::reverse_iterator< iterator >;
+
+      static constexpr size_type extent = dynamic_extent;
+
+      constexpr span() noexcept
+         : m_data( nullptr ), m_size( 0 )
+      {}
+
+      constexpr span( pointer ptr, size_type count ) noexcept
+         : m_data( ptr ), m_size( count )
+      {}
+
+      constexpr span( pointer first, pointer last ) noexcept
+         : m_data( first ), m_size( std::distance( first, last ) )
+      {}
+
+      template< std::size_t N >
+      constexpr span( element_type ( &arr )[ N ] ) noexcept
+         : m_data( arr ), m_size( N )
+      {}
+
+      template< typename OtherElementType, std::size_t N, typename = std::enable_if_t< tao::internal::is_span_compatible_ptr< OtherElementType, ElementType > > >
+      constexpr span( std::array< OtherElementType, N >& arr ) noexcept
+         : m_data( static_cast< pointer >( arr.data() ) ), m_size( N )
+      {}
+
+      template< typename OtherElementType, std::size_t N, typename = std::enable_if_t< tao::internal::is_span_compatible_ptr< const OtherElementType, ElementType > > >
+      constexpr span( const std::array< OtherElementType, N >& arr ) noexcept
+         : m_data( static_cast< pointer >( arr.data() ) ), m_size( N )
+      {}
+
+      template< typename Container, typename = std::enable_if_t< tao::internal::is_span_compatible_container< Container, ElementType > > >
+      constexpr span( Container& cont )
+         : m_data( static_cast< pointer >( std::data( cont ) ) ), m_size( std::size( cont ) )
+      {}
+
+      template< typename Container, typename = std::enable_if_t< tao::internal::is_span_compatible_container< const Container, ElementType > > >
+      constexpr span( const Container& cont )
+         : m_data( static_cast< pointer >( std::data( cont ) ) ), m_size( std::size( cont ) )
+      {}
+
+      constexpr span( const span& ) = default;
+
+      template< typename OtherElementType, std::size_t OtherExtent, typename = std::enable_if_t< tao::internal::is_span_compatible_ptr< OtherElementType, ElementType > > >
+      constexpr span( const span< OtherElementType, OtherExtent >& s ) noexcept
+         : m_data( s.data() ), m_size( s.size() )
+      {}
+
+      ~span() = default;
+
+      constexpr auto operator=( const span& ) -> span& = default;
+
+      constexpr auto size() const noexcept -> size_type  // NOLINT(modernize-use-nodiscard)
+      {
+         return m_size;
+      }
+
+      constexpr auto size_bytes() const noexcept -> size_type  // NOLINT(modernize-use-nodiscard)
+      {
+         return size() * sizeof( element_type );
+      }
+
+      [[nodiscard]] constexpr auto empty() const noexcept -> bool
+      {
+         return size() == 0;
+      }
+
+      constexpr auto operator[]( size_type idx ) const noexcept -> reference
+      {
+         assert( idx < size() );
+         return *( data() + idx );
+      }
+
+      constexpr auto front() const noexcept -> reference
+      {
+         assert( !empty() );
+         return *data();
+      }
+
+      constexpr auto back() const noexcept -> reference
+      {
+         assert( !empty() );
+         return *( data() + ( size() - 1 ) );
+      }
+
+      constexpr auto data() const noexcept -> pointer
+      {
+         return m_data;
+      }
+
+      constexpr auto begin() const noexcept -> iterator
+      {
+         return data();
+      }
+
+      constexpr auto end() const noexcept -> iterator
+      {
+         return data() + size();
+      }
+
+      constexpr auto rbegin() const noexcept -> reverse_iterator
+      {
+         return reverse_iterator( end() );
+      }
+
+      constexpr auto rend() const noexcept -> reverse_iterator
+      {
+         return reverse_iterator( begin() );
+      }
+
+      template< std::size_t Count >
+      constexpr auto first() const noexcept
+         -> span< element_type, Count >
+      {
+         assert( Count <= size() );
+         return { data(), Count };
+      }
+
+      template< std::size_t Count >
+      constexpr auto last() const noexcept
+         -> span< element_type, Count >
+      {
+         assert( Count <= size() );
+         return { data() + ( size() - Count ), Count };
+      }
+
+      template< std::size_t Offset, std::size_t Count = dynamic_extent >
+      constexpr auto subspan() const
+         -> span< element_type, ( ( Count != dynamic_extent ) ? Count : dynamic_extent ) >
+      {
+         assert( Offset <= size() );
+         assert( ( Count == dynamic_extent ) || ( Count <= ( size() - Offset ) ) );
+         return { data() + Offset, ( Count != dynamic_extent ) ? Count : ( size() - Offset ) };
+      }
+
+      constexpr auto first( size_type count ) const
+         -> span< element_type, dynamic_extent >
+      {
+         assert( count <= size() );
+         return { data(), count };
+      }
+
+      constexpr auto last( size_type count ) const
+         -> span< element_type, dynamic_extent >
+      {
+         assert( count <= size() );
+         return { data() + size() - count, count };
+      }
+
+      constexpr auto subspan( size_type offset, size_type count = dynamic_extent ) const
+         -> span< element_type, dynamic_extent >
+      {
+         assert( offset <= size() );
+         assert( ( count == dynamic_extent ) || ( count <= ( size() - offset ) ) );
+         return { data() + offset, ( count != dynamic_extent ) ? count : ( size() - offset ) };
+      }
+
+   private:
+      pointer m_data;
+      size_type m_size;  // NOLINT(modernize-use-default-member-init)
+   };
+
+   template< typename ElementType, std::size_t Extent >
+   auto as_bytes( span< ElementType, Extent > s ) noexcept
+      -> span< const std::byte, ( ( Extent == dynamic_extent ) ? dynamic_extent : ( sizeof( ElementType ) * Extent ) ) >
+   {
+      return { reinterpret_cast< const std::byte* >( s.data() ), s.size_bytes() };
+   }
+
+   template< typename ElementType, std::size_t Extent, typename = std::enable_if_t< !std::is_const_v< ElementType > > >
+   auto as_writable_bytes( span< ElementType, Extent > s ) noexcept
+      -> span< std::byte, ( ( Extent == dynamic_extent ) ? dynamic_extent : ( sizeof( ElementType ) * Extent ) ) >
+   {
+      return { reinterpret_cast< std::byte* >( s.data() ), s.size_bytes() };
+   }
+
+   // deduction guides
+   template< typename T, std::size_t N >
+   span( T ( & )[ N ] ) -> span< T, N >;
+
+   template< typename T, std::size_t N >
+   span( std::array< T, N >& ) -> span< T, N >;
+
+   template< typename T, std::size_t N >
+   span( const std::array< T, N >& ) -> span< const T, N >;
+
+   template< typename Container >
+   span( Container& ) -> span< typename Container::value_type >;
+
+   template< typename Container >
+   span( const Container& ) -> span< const typename Container::value_type >;
+
+}  // namespace tao
+
+namespace std
+{
+#if defined( __clang__ )
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+
+   template< typename ElementType, size_t Extent >
+   struct tuple_size< tao::span< ElementType, Extent > >
+      : integral_constant< size_t, Extent >
+   {};
+
+   template< typename ElementType >
+   struct tuple_size< tao::span< ElementType, tao::dynamic_extent > >;  // not defined
+
+   template< size_t I, typename ElementType, size_t Extent >
+   struct tuple_element< I, tao::span< ElementType, Extent > >
+   {
+      static_assert( ( Extent != tao::dynamic_extent ) && ( I < Extent ) );
+      using type = ElementType;
+   };
+
+#if defined( __clang__ )
+#pragma clang diagnostic pop
+#endif
+
+   // TODO: this is probably illegal. keep it?
+   template< size_t I, typename ElementType, size_t Extent >
+   constexpr auto get( tao::span< ElementType, Extent > s ) noexcept -> ElementType&
+   {
+      static_assert( ( Extent != tao::dynamic_extent ) && ( I < Extent ) );
+      return s[ I ];
+   }
+
+}  // namespace std
+
+#endif
+
+#endif