couchbase 3.0.0.alpha.3-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/third_party/json/include/tao/json/jaxn/is_identifier.hpp

@@ -11,11 +11,11 @@ namespace tao::json::jaxn
 {
    [[nodiscard]] inline bool is_identifier( const std::string_view v ) noexcept
    {
-      if( v.empty() || std::isdigit( v[ 0 ] ) ) {
+      if( v.empty() || ( std::isdigit( v[ 0 ] ) != 0 ) ) {
          return false;
       }
       for( const auto c : v ) {
-         if( !std::isalnum( c ) && c != '_' ) {
+         if( ( std::isalnum( c ) == 0 ) && ( c != '_' ) ) {
             return false;
          }
       }

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

@@ -20,8 +20,6 @@ namespace tao::json::jaxn
       {
          struct double_rule
          {
-            using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
-
             template< apply_mode A,
                       rewind_mode M,
                       template< typename... >
@@ -106,7 +104,7 @@ namespace tao::json::jaxn
 
       [[nodiscard]] bool null()
       {
-         return pegtl::parse< pegtl::seq< json::internal::rules::null, json::internal::rules::wss > >( m_input );
+         return pegtl::parse< pegtl::seq< json::internal::rules::kw_null, json::internal::rules::wss > >( m_input );
       }
 
       [[nodiscard]] bool boolean()

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

@@ -25,7 +25,7 @@ namespace tao::json
    };
 
    template< typename T >
-   struct message_extension< T, decltype( std::declval< const T& >().public_base().append_message_extension( std::declval< std::ostream& >() ), void() ) >
+   struct message_extension< T, decltype( (void)std::declval< const T& >().public_base().append_message_extension( std::declval< std::ostream& >() ) ) >
    {
       const T& m_v;
 
@@ -42,7 +42,7 @@ namespace tao::json
    };
 
    template< typename T >
-   message_extension( const T& )->message_extension< T >;
+   message_extension( const T& ) -> message_extension< T >;
 
 }  // namespace tao::json
 

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

@@ -8,6 +8,7 @@
 
 #include "msgpack/consume_file.hpp"
 #include "msgpack/consume_string.hpp"
+#include "msgpack/from_binary.hpp"
 #include "msgpack/from_file.hpp"
 #include "msgpack/from_input.hpp"
 #include "msgpack/from_string.hpp"

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

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_MSGPACK_CONSUME_FILE_HPP
 #define TAO_JSON_MSGPACK_CONSUME_FILE_HPP
 
-#include <utility>
+#include <filesystem>
 
 #include "../external/pegtl/file_input.hpp"
 
@@ -15,17 +15,17 @@
 
 namespace tao::json::msgpack
 {
-   template< typename T, template< typename... > class Traits = traits, typename F >
-   [[nodiscard]] T consume_file( F&& filename )
+   template< typename T, template< typename... > class Traits = traits >
+   [[nodiscard]] T consume_file( const std::filesystem::path& path )
    {
-      msgpack::basic_parts_parser< utf8_mode::check, pegtl::file_input< pegtl::tracking_mode::lazy > > pp( std::forward< F >( filename ) );
+      msgpack::basic_parts_parser< utf8_mode::check, pegtl::file_input< pegtl::tracking_mode::lazy > > pp( path );
       return json::consume< T, Traits >( pp );
    }
 
-   template< template< typename... > class Traits = traits, typename F, typename T >
-   void consume_file( F&& filename, T& t )
+   template< template< typename... > class Traits = traits, typename T >
+   void consume_file( const std::filesystem::path& path, T& t )
    {
-      msgpack::basic_parts_parser< utf8_mode::check, pegtl::file_input< pegtl::tracking_mode::lazy > > pp( std::forward< F >( filename ) );
+      msgpack::basic_parts_parser< utf8_mode::check, pegtl::file_input< pegtl::tracking_mode::lazy > > pp( path );
       json::consume< Traits >( pp, t );
    }
 

data/ext/third_party/json/include/tao/json/msgpack/events/from_binary.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_MSGPACK_EVENTS_FROM_BINARY_HPP
+#define TAO_JSON_MSGPACK_EVENTS_FROM_BINARY_HPP
+
+#include "../../binary.hpp"
+#include "../../binary_view.hpp"
+#include "../../external/pegtl/memory_input.hpp"
+
+#include "from_input.hpp"
+
+namespace tao::json::msgpack::events
+{
+   template< typename Consumer >
+   void from_binary( Consumer& consumer, const void* data, const std::size_t size, const char* source = nullptr, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
+   {
+      const char* cast = static_cast< const char* >( data );
+      pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > in( cast, cast + size, source ? source : "tao::json::msgpack::events::from_binary", byte, line, column );
+      msgpack::events::from_input( consumer, std::move( in ) );
+   }
+
+   template< typename Consumer >
+   void from_binary( Consumer& consumer, const void* data, const std::size_t size, const std::string& source, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
+   {
+      msgpack::events::from_binary( consumer, data, size, source.c_str(), byte, line, column );
+   }
+
+   template< typename Consumer, typename... Ts >
+   void from_binary( Consumer& consumer, const tao::binary& data, Ts&&... ts )
+   {
+      msgpack::events::from_binary( consumer, data.data(), data.size(), std::forward< Ts >( ts )... );
+   }
+
+   template< typename Consumer, typename... Ts >
+   void from_binary( Consumer& consumer, const tao::binary_view data, Ts&&... ts )
+   {
+      msgpack::events::from_binary( consumer, data.data(), data.size(), std::forward< Ts >( ts )... );
+   }
+
+}  // namespace tao::json::msgpack::events
+
+#endif

data/ext/third_party/json/include/tao/json/msgpack/events/from_file.hpp

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_MSGPACK_EVENTS_FROM_FILE_HPP
 #define TAO_JSON_MSGPACK_EVENTS_FROM_FILE_HPP
 
-#include <utility>
+#include <filesystem>
 
 #include "../../external/pegtl/file_input.hpp"
 #include "../../external/pegtl/parse.hpp"
@@ -15,10 +15,10 @@ namespace tao::json::msgpack::events
 {
    // Events producer to parse a file containing a MSGPACK string representation.
 
-   template< typename T, typename Consumer >
-   void from_file( Consumer& consumer, T&& filename )
+   template< typename Consumer >
+   void from_file( Consumer& consumer, const std::filesystem::path& path )
    {
-      pegtl::file_input< pegtl::tracking_mode::lazy > in( std::forward< T >( filename ) );
+      pegtl::file_input< pegtl::tracking_mode::lazy > in( path );
       pegtl::parse< internal::grammar >( in, consumer );
    }
 

data/ext/third_party/json/include/tao/json/msgpack/events/from_string.hpp

@@ -14,16 +14,16 @@
 namespace tao::json::msgpack::events
 {
    template< typename Consumer >
-   void from_string( Consumer& consumer, const char* data, const std::size_t size, const char* source = nullptr, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t byte_in_line = 0 )
+   void from_string( Consumer& consumer, const char* data, const std::size_t size, const char* source = nullptr, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
    {
-      pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > in( data, data + size, source ? source : "tao::json::msgpack::from_string", byte, line, byte_in_line );
+      pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > in( data, data + size, source ? source : "tao::json::msgpack::from_string", byte, line, column );
       msgpack::events::from_input( consumer, std::move( in ) );
    }
 
    template< typename Consumer >
-   void from_string( Consumer& consumer, const char* data, const std::size_t size, const std::string& source, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t byte_in_line = 0 )
+   void from_string( Consumer& consumer, const char* data, const std::size_t size, const std::string& source, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
    {
-      msgpack::events::from_string( consumer, data, size, source.c_str(), byte, line, byte_in_line );
+      msgpack::events::from_string( consumer, data, size, source.c_str(), byte, line, column );
    }
 
    template< typename Consumer, typename... Ts >

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

@@ -135,7 +135,7 @@ namespace tao::json::msgpack::events
          os.write( reinterpret_cast< const char* >( v.data() ), v.size() );
       }
 
-      void begin_array()
+      void begin_array()  // NOLINT(readability-convert-member-functions-to-static)
       {
          throw std::runtime_error( "msgpack requires array size" );
       }
@@ -159,7 +159,7 @@ namespace tao::json::msgpack::events
       void element() noexcept
       {}
 
-      void end_array()
+      void end_array()  // NOLINT(readability-convert-member-functions-to-static)
       {
          assert( false );  // LCOV_EXCL_LINE
       }
@@ -167,7 +167,7 @@ namespace tao::json::msgpack::events
       void end_array( const std::size_t /*unused*/ ) noexcept
       {}
 
-      void begin_object()
+      void begin_object()  // NOLINT(readability-convert-member-functions-to-static)
       {
          throw std::runtime_error( "msgpack requires object size" );
       }
@@ -196,7 +196,7 @@ namespace tao::json::msgpack::events
       void member() noexcept
       {}
 
-      void end_object()
+      void end_object()  // NOLINT(readability-convert-member-functions-to-static)
       {
          assert( false );  // LCOV_EXCL_LINE
       }

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

@@ -0,0 +1,32 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_MSGPACK_FROM_BINARY_HPP
+#define TAO_JSON_MSGPACK_FROM_BINARY_HPP
+
+#include <utility>
+
+#include "../events/to_value.hpp"
+#include "../events/transformer.hpp"
+
+#include "events/from_binary.hpp"
+
+namespace tao::json::msgpack
+{
+   template< template< typename... > class Traits, template< typename... > class... Transformers, typename... Ts >
+   [[nodiscard]] basic_value< Traits > basic_from_binary( Ts&&... ts )
+   {
+      json::events::transformer< json::events::to_basic_value< Traits >, Transformers... > consumer;
+      events::from_binary( consumer, std::forward< Ts >( ts )... );
+      return std::move( consumer.value );
+   }
+
+   template< template< typename... > class... Transformers, typename... Ts >
+   [[nodiscard]] value from_binary( Ts&&... ts )
+   {
+      return basic_from_binary< traits, Transformers... >( std::forward< Ts >( ts )... );
+   }
+
+}  // namespace tao::json::msgpack
+
+#endif

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

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_MSGPACK_FROM_FILE_HPP
 #define TAO_JSON_MSGPACK_FROM_FILE_HPP
 
-#include <string>
+#include <filesystem>
 #include <utility>
 
 #include "../events/to_value.hpp"
@@ -15,17 +15,17 @@
 namespace tao::json::msgpack
 {
    template< template< typename... > class Traits, template< typename... > class... Transformers >
-   [[nodiscard]] basic_value< Traits > basic_from_file( const std::string& filename )
+   [[nodiscard]] basic_value< Traits > basic_from_file( const std::filesystem::path& path )
    {
       json::events::transformer< json::events::to_basic_value< Traits >, Transformers... > consumer;
-      events::from_file( consumer, filename );
+      events::from_file( consumer, path );
       return std::move( consumer.value );
    }
 
    template< template< typename... > class... Transformers >
-   [[nodiscard]] value from_file( const std::string& filename )
+   [[nodiscard]] value from_file( const std::filesystem::path& path )
    {
-      return basic_from_file< traits, Transformers... >( filename );
+      return basic_from_file< traits, Transformers... >( path );
    }
 
 }  // namespace tao::json::msgpack

data/ext/third_party/json/include/tao/json/msgpack/internal/grammar.hpp

@@ -41,7 +41,8 @@ namespace tao::json::msgpack::internal
    template< utf8_mode V >
    struct data
    {
-      using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
+      using rule_t = data;
+      using subs_t = pegtl::empty_list;  // TODO?
 
       template< pegtl::apply_mode A,
                 pegtl::rewind_mode M,

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

@@ -87,8 +87,6 @@ namespace tao::json
 
       switch( lhs.type() ) {
          case type::UNINITIALIZED:
-            return true;
-
          case type::NULL_:
             return true;
 
@@ -286,8 +284,6 @@ namespace tao::json
 
       switch( lhs.type() ) {
          case type::UNINITIALIZED:
-            return false;
-
          case type::NULL_:
             return false;
 

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

@@ -26,8 +26,6 @@ namespace tao::json
 
          struct boolean
          {
-            using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
-
             template< pegtl::apply_mode,
                       pegtl::rewind_mode,
                       template< typename... >
@@ -58,8 +56,6 @@ namespace tao::json
 
          struct double_rule
          {
-            using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
-
             template< apply_mode A,
                       rewind_mode M,
                       template< typename... >
@@ -157,7 +153,7 @@ namespace tao::json
 
       [[nodiscard]] bool null()
       {
-         return pegtl::parse< pegtl::seq< internal::rules::null, internal::rules::wss > >( m_input );
+         return pegtl::parse< pegtl::seq< internal::rules::kw_null, internal::rules::wss > >( m_input );
       }
 
       [[nodiscard]] bool boolean()
@@ -177,14 +173,14 @@ namespace tao::json
       [[nodiscard]] std::int64_t number_signed()
       {
          std::int64_t st = 0;  // TODO: Remove superfluous initialisation when we manage to shup up the warnings on all compilers.
-         pegtl::parse< pegtl::must< pegtl::integer::signed_rule_with_action, internal::rules::wss > >( m_input, st );
+         pegtl::parse< pegtl::must< pegtl::signed_rule_with_action, internal::rules::wss > >( m_input, st );
          return st;
       }
 
       [[nodiscard]] std::uint64_t number_unsigned()
       {
          std::uint64_t st = 0;  // TODO: Remove superfluous initialisation when we manage to shup up the warnings on all compilers.
-         pegtl::parse< pegtl::must< pegtl::integer::unsigned_rule_with_action, internal::rules::wss > >( m_input, st );
+         pegtl::parse< pegtl::must< pegtl::unsigned_rule_with_action, internal::rules::wss > >( m_input, st );
          return st;
       }
 

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

@@ -20,8 +20,6 @@ namespace tao::json
    {
       switch( v.type() ) {
          case type::UNINITIALIZED:
-            return true;
-
          case type::NULL_:
          case type::BOOLEAN:
          case type::SIGNED:
@@ -29,14 +27,17 @@ namespace tao::json
          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( auto& e : v.get_array() ) {
+            for( const auto& e : v.get_array() ) {
                if( !is_self_contained( e ) ) {
                   return false;
                }
@@ -44,21 +45,12 @@ namespace tao::json
             return true;
 
          case type::OBJECT:
-            for( auto& e : v.get_object() ) {
+            for( const auto& e : v.get_object() ) {
                if( !is_self_contained( e.second ) ) {
                   return false;
                }
             }
             return true;
-
-         case type::VALUE_PTR:
-            return false;
-
-         case type::OPAQUE_PTR:
-            return false;
-
-         case type::VALUELESS_BY_EXCEPTION:
-            return true;
       }
       // LCOV_EXCL_START
       assert( false );
@@ -76,8 +68,6 @@ namespace tao::json
    {
       switch( v.type() ) {
          case type::UNINITIALIZED:
-            return;
-
          case type::NULL_:
          case type::BOOLEAN:
          case type::SIGNED:
@@ -85,6 +75,7 @@ namespace tao::json
          case type::DOUBLE:
          case type::STRING:
          case type::BINARY:
+         case type::VALUELESS_BY_EXCEPTION:
             return;
 
          case type::STRING_VIEW:
@@ -123,9 +114,6 @@ namespace tao::json
             v = std::move( consumer.value );
             return;
          }
-
-         case type::VALUELESS_BY_EXCEPTION:
-            return;
       }
       throw std::logic_error( "invalid value for tao::json::type" );  // LCOV_EXCL_LINE
    }

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 ];