couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

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

@@ -46,81 +46,61 @@ namespace tao
    namespace internal
    {
       template< typename >
-      struct is_span_impl
-         : std::false_type
-      {};
+      inline constexpr bool is_span = false;
 
       template< typename ElementType, std::size_t Extent >
-      struct is_span_impl< span< ElementType, Extent > >
-         : std::true_type
-      {};
-
-      template< typename T >
-      using is_span = is_span_impl< std::remove_cv_t< T > >;
+      inline constexpr bool is_span< span< ElementType, Extent > > = true;
 
       template< typename >
-      struct is_std_array_impl
-         : std::false_type
-      {};
+      inline constexpr bool is_std_array = false;
 
       template< typename T, std::size_t N >
-      struct is_std_array_impl< std::array< T, N > >
-         : std::true_type
-      {};
-
-      template< typename T >
-      using is_std_array = is_std_array_impl< std::remove_cv_t< T > >;
+      inline constexpr bool is_std_array< std::array< T, N > > = true;
 
       template< typename T, typename ElementType >
-      using is_span_compatible_ptr = std::is_convertible< T ( * )[], ElementType ( * )[] >;
+      inline constexpr bool is_span_compatible_ptr = std::is_convertible_v< T ( * )[], ElementType ( * )[] >;
 
       template< typename, typename, typename = void >
-      struct is_span_compatible_container
-         : std::false_type
-      {};
+      inline constexpr bool is_span_compatible_container = false;
 
       template< typename Container, typename ElementType >
-      struct is_span_compatible_container< Container,
-                                           ElementType,
-                                           std::void_t<
-                                              std::enable_if_t< !is_span< Container >::value >,
-                                              std::enable_if_t< !is_std_array< Container >::value >,
-                                              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< is_span_compatible_ptr< std::remove_pointer_t< decltype( std::data( std::declval< Container& >() ) ) >, ElementType >::value > > >
-         : std::true_type
-      {};
+      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
+   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 index_type = std::size_t;
+      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 const_iterator = const_pointer;
       using reverse_iterator = std::reverse_iterator< iterator >;
-      using const_reverse_iterator = std::reverse_iterator< const_iterator >;
 
-      static constexpr index_type extent = Extent;
+      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, index_type count ) noexcept
+      constexpr span( pointer ptr, size_type count ) noexcept
          : m_data( ptr )
       {
          assert( count == Extent );
@@ -136,124 +116,96 @@ namespace tao
          : m_data( arr )
       {}
 
-      template< std::size_t N, typename = std::enable_if_t< ( N == Extent ) && tao::internal::is_span_compatible_ptr< value_type, ElementType >::value > >
-      constexpr span( std::array< value_type, N >& arr ) noexcept
-         : m_data( arr.data() )
+      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< std::size_t N, typename = std::enable_if_t< ( N == Extent ) && tao::internal::is_span_compatible_ptr< const value_type, ElementType >::value > >
-      constexpr span( const std::array< value_type, N >& arr ) noexcept
-         : m_data( 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& other ) = default;
+      constexpr span( const span& ) = default;
 
-      template< typename OtherElementType, typename = std::enable_if_t< tao::internal::is_span_compatible_ptr< OtherElementType, ElementType >::value > >
+      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 span& operator=( const span& ) = default;
+      constexpr auto operator=( const span& ) -> span& = default;
 
-      constexpr index_type size() const noexcept
+      constexpr auto size() const noexcept -> size_type  // NOLINT(modernize-use-nodiscard)
       {
          return Extent;
       }
 
-      constexpr index_type size_bytes() const noexcept
+      constexpr auto size_bytes() const noexcept -> size_type  // NOLINT(modernize-use-nodiscard)
       {
          return Extent * sizeof( element_type );
       }
 
-      [[nodiscard]] constexpr bool empty() const noexcept
+      [[nodiscard]] constexpr auto empty() const noexcept -> bool
       {
          return Extent == 0;
       }
 
-      constexpr reference operator[]( index_type idx ) const noexcept
+      constexpr auto operator[]( size_type idx ) const noexcept -> reference
       {
          assert( idx < Extent );
          return *( data() + idx );
       }
 
-      constexpr reference front() const noexcept
+      constexpr auto front() const noexcept -> reference
       {
          assert( Extent != 0 );
          return *data();
       }
 
-      constexpr reference back() const noexcept
+      constexpr auto back() const noexcept -> reference
       {
          assert( Extent != 0 );
          return *( data() + ( Extent - 1 ) );
       }
 
-      constexpr pointer data() const noexcept
+      constexpr auto data() const noexcept -> pointer
       {
          return m_data;
       }
 
-      constexpr iterator begin() const noexcept
-      {
-         return data();
-      }
-
-      constexpr const_iterator cbegin() const noexcept
+      constexpr auto begin() const noexcept -> iterator
       {
          return data();
       }
 
-      constexpr iterator end() const noexcept
+      constexpr auto end() const noexcept -> iterator
       {
          return data() + Extent;
       }
 
-      constexpr const_iterator cend() const noexcept
-      {
-         return data() + Extent;
-      }
-
-      constexpr reverse_iterator rbegin() const noexcept
+      constexpr auto rbegin() const noexcept -> reverse_iterator
       {
          return reverse_iterator( end() );
       }
 
-      constexpr reverse_iterator rend() const noexcept
+      constexpr auto rend() const noexcept -> reverse_iterator
       {
          return reverse_iterator( begin() );
       }
 
-      constexpr const_reverse_iterator crbegin() const noexcept
-      {
-         return const_reverse_iterator( cend() );
-      }
-
-      constexpr const_reverse_iterator crend() const noexcept
-      {
-         return const_reverse_iterator( cbegin() );
-      }
-
-      friend constexpr iterator begin( span s ) noexcept
-      {
-         return s.begin();
-      }
-
-      friend constexpr iterator end( span s ) noexcept
-      {
-         return s.end();
-      }
-
       template< std::size_t Count >
-      constexpr span< element_type, Count > first() const noexcept
+      constexpr auto first() const noexcept
+         -> span< element_type, Count >
       {
          static_assert( Count <= Extent );
          return { data(), Count };
       }
 
       template< std::size_t Count >
-      constexpr span< element_type, Count > last() const noexcept
+      constexpr auto last() const noexcept
+         -> span< element_type, Count >
       {
          static_assert( Count <= Extent );
          return { data() + ( Extent - Count ), Count };
@@ -268,19 +220,22 @@ namespace tao
          return { data() + Offset, ( Count != dynamic_extent ) ? Count : ( Extent - Offset ) };
       }
 
-      constexpr span< element_type, dynamic_extent > first( index_type count ) const
+      constexpr auto first( size_type count ) const
+         -> span< element_type, dynamic_extent >
       {
          assert( count <= Extent );
          return { data(), count };
       }
 
-      constexpr span< element_type, dynamic_extent > last( index_type count ) const
+      constexpr auto last( size_type count ) const
+         -> span< element_type, dynamic_extent >
       {
          assert( count <= Extent );
          return { data() + Extent - count, count };
       }
 
-      constexpr span< element_type, dynamic_extent > subspan( index_type offset, index_type count = dynamic_extent ) const
+      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 ) ) );
@@ -292,31 +247,29 @@ namespace tao
    };
 
    template< typename ElementType >
-   class span< ElementType, dynamic_extent >
+   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 index_type = std::size_t;
+      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 const_iterator = const_pointer;
       using reverse_iterator = std::reverse_iterator< iterator >;
-      using const_reverse_iterator = std::reverse_iterator< const_iterator >;
 
-      static constexpr index_type extent = dynamic_extent;
+      static constexpr size_type extent = dynamic_extent;
 
       constexpr span() noexcept
          : m_data( nullptr ), m_size( 0 )
       {}
 
-      constexpr span( pointer ptr, index_type count ) noexcept
+      constexpr span( pointer ptr, size_type count ) noexcept
          : m_data( ptr ), m_size( count )
       {}
 
@@ -329,134 +282,106 @@ namespace tao
          : m_data( arr ), m_size( N )
       {}
 
-      template< std::size_t N, typename = std::enable_if_t< tao::internal::is_span_compatible_ptr< value_type, ElementType >::value > >
-      constexpr span( std::array< value_type, N >& arr ) noexcept
-         : m_data( arr.data() ), 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< std::size_t N, typename = std::enable_if_t< tao::internal::is_span_compatible_ptr< const value_type, ElementType >::value > >
-      constexpr span( const std::array< value_type, N >& arr ) noexcept
-         : m_data( 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 >::value > >
+      template< typename Container, typename = std::enable_if_t< tao::internal::is_span_compatible_container< Container, ElementType > > >
       constexpr span( Container& cont )
-         : m_data( std::data( cont ) ), m_size( std::size( 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 >::value > >
+      template< typename Container, typename = std::enable_if_t< tao::internal::is_span_compatible_container< const Container, ElementType > > >
       constexpr span( const Container& cont )
-         : m_data( std::data( cont ) ), m_size( std::size( cont ) )
+         : m_data( static_cast< pointer >( std::data( cont ) ) ), m_size( std::size( cont ) )
       {}
 
-      constexpr span( const span& other ) = default;
+      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 >::value > >
+      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 span& operator=( const span& ) = default;
+      constexpr auto operator=( const span& ) -> span& = default;
 
-      constexpr index_type size() const noexcept
+      constexpr auto size() const noexcept -> size_type  // NOLINT(modernize-use-nodiscard)
       {
          return m_size;
       }
 
-      constexpr index_type size_bytes() const noexcept
+      constexpr auto size_bytes() const noexcept -> size_type  // NOLINT(modernize-use-nodiscard)
       {
          return size() * sizeof( element_type );
       }
 
-      [[nodiscard]] constexpr bool empty() const noexcept
+      [[nodiscard]] constexpr auto empty() const noexcept -> bool
       {
          return size() == 0;
       }
 
-      constexpr reference operator[]( index_type idx ) const noexcept
+      constexpr auto operator[]( size_type idx ) const noexcept -> reference
       {
          assert( idx < size() );
          return *( data() + idx );
       }
 
-      constexpr reference front() const noexcept
+      constexpr auto front() const noexcept -> reference
       {
          assert( !empty() );
          return *data();
       }
 
-      constexpr reference back() const noexcept
+      constexpr auto back() const noexcept -> reference
       {
          assert( !empty() );
          return *( data() + ( size() - 1 ) );
       }
 
-      constexpr pointer data() const noexcept
+      constexpr auto data() const noexcept -> pointer
       {
          return m_data;
       }
 
-      constexpr iterator begin() const noexcept
-      {
-         return data();
-      }
-
-      constexpr const_iterator cbegin() const noexcept
+      constexpr auto begin() const noexcept -> iterator
       {
          return data();
       }
 
-      constexpr iterator end() const noexcept
+      constexpr auto end() const noexcept -> iterator
       {
          return data() + size();
       }
 
-      constexpr const_iterator cend() const noexcept
-      {
-         return data() + size();
-      }
-
-      constexpr reverse_iterator rbegin() const noexcept
+      constexpr auto rbegin() const noexcept -> reverse_iterator
       {
          return reverse_iterator( end() );
       }
 
-      constexpr reverse_iterator rend() const noexcept
+      constexpr auto rend() const noexcept -> reverse_iterator
       {
          return reverse_iterator( begin() );
       }
 
-      constexpr const_reverse_iterator crbegin() const noexcept
-      {
-         return const_reverse_iterator( cend() );
-      }
-
-      constexpr const_reverse_iterator crend() const noexcept
-      {
-         return const_reverse_iterator( cbegin() );
-      }
-
-      friend constexpr iterator begin( span s ) noexcept
-      {
-         return s.begin();
-      }
-
-      friend constexpr iterator end( span s ) noexcept
-      {
-         return s.end();
-      }
-
       template< std::size_t Count >
-      constexpr span< element_type, Count > first() const noexcept
+      constexpr auto first() const noexcept
+         -> span< element_type, Count >
       {
          assert( Count <= size() );
          return { data(), Count };
       }
 
       template< std::size_t Count >
-      constexpr span< element_type, Count > last() const noexcept
+      constexpr auto last() const noexcept
+         -> span< element_type, Count >
       {
          assert( Count <= size() );
          return { data() + ( size() - Count ), Count };
@@ -471,19 +396,22 @@ namespace tao
          return { data() + Offset, ( Count != dynamic_extent ) ? Count : ( size() - Offset ) };
       }
 
-      constexpr span< element_type, dynamic_extent > first( index_type count ) const
+      constexpr auto first( size_type count ) const
+         -> span< element_type, dynamic_extent >
       {
          assert( count <= size() );
          return { data(), count };
       }
 
-      constexpr span< element_type, dynamic_extent > last( index_type count ) const
+      constexpr auto last( size_type count ) const
+         -> span< element_type, dynamic_extent >
       {
          assert( count <= size() );
          return { data() + size() - count, count };
       }
 
-      constexpr span< element_type, dynamic_extent > subspan( index_type offset, index_type count = dynamic_extent ) const
+      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 ) ) );
@@ -492,7 +420,7 @@ namespace tao
 
    private:
       pointer m_data;
-      index_type m_size;
+      size_type m_size;  // NOLINT(modernize-use-default-member-init)
    };
 
    template< typename ElementType, std::size_t Extent >
@@ -511,19 +439,19 @@ namespace tao
 
    // deduction guides
    template< typename T, std::size_t N >
-   span( T ( & )[ N ] )->span< T, N >;
+   span( T ( & )[ N ] ) -> span< T, N >;
 
    template< typename T, std::size_t N >
-   span( std::array< T, N >& )->span< 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 >;
+   span( const std::array< T, N >& ) -> span< const T, N >;
 
    template< typename Container >
-   span( Container& )->span< typename Container::value_type >;
+   span( Container& ) -> span< typename Container::value_type >;
 
    template< typename Container >
-   span( const Container& )->span< const typename Container::value_type >;
+   span( const Container& ) -> span< const typename Container::value_type >;
 
 }  // namespace tao
 
@@ -555,7 +483,7 @@ namespace std
 
    // TODO: this is probably illegal. keep it?
    template< size_t I, typename ElementType, size_t Extent >
-   constexpr ElementType& get( tao::span< ElementType, Extent > s ) noexcept
+   constexpr auto get( tao::span< ElementType, Extent > s ) noexcept -> ElementType&
    {
       static_assert( ( Extent != tao::dynamic_extent ) && ( I < Extent ) );
       return s[ I ];