clang-tidy

d-frey · d-frey · commit 22a7c30c9432 · 2023-04-28T16:58:42.000+02:00
diff --git a/.clang-tidy b/.clang-tidy
@@ -29,6 +29,7 @@ Checks: >-
   performance-*,
   readability-*,
   -readability-avoid-const-params-in-decls,
+  -readability-function-cognitive-complexity,
   -readability-identifier-length,
   -readability-magic-numbers,
 
diff --git a/include/tao/json/cbor/events/to_stream.hpp b/include/tao/json/cbor/events/to_stream.hpp
@@ -34,35 +34,35 @@ namespace tao::json::cbor::events
 
       void null()
       {
-         os.put( char( std::uint8_t( internal::major::OTHER ) + 22 ) );
+         os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::OTHER ) + 22 ) );
       }
 
       void boolean( const bool v )
       {
-         os.put( char( std::uint8_t( internal::major::OTHER ) + 20 + std::uint8_t( v ) ) );
+         os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::OTHER ) + 20 + static_cast< std::uint8_t >( v ) ) );
       }
 
       void number( const internal::major m, const std::uint64_t v )
       {
          if( v < 24 ) {
-            os.put( char( std::uint8_t( m ) + v ) );
+            os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + v ) );
          }
          else if( v < 256 ) {
-            os.put( char( std::uint8_t( m ) + 24 ) );
-            os.put( char( v ) );
+            os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + 24 ) );
+            os.put( static_cast< char >( v ) );
          }
          else if( v < 65536 ) {
-            os.put( char( std::uint8_t( m ) + 25 ) );
-            const std::uint16_t x = json::internal::h_to_be( std::uint16_t( v ) );
+            os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + 25 ) );
+            const std::uint16_t x = json::internal::h_to_be( static_cast< std::uint16_t >( v ) );
             os.write( reinterpret_cast< const char* >( &x ), sizeof( x ) );
          }
          else if( v < 4294967296ULL ) {
-            os.put( char( std::uint8_t( m ) + 26 ) );
-            const std::uint32_t x = json::internal::h_to_be( std::uint32_t( v ) );
+            os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + 26 ) );
+            const std::uint32_t x = json::internal::h_to_be( static_cast< std::uint32_t >( v ) );
             os.write( reinterpret_cast< const char* >( &x ), sizeof( x ) );
          }
          else {
-            os.put( char( std::uint8_t( m ) + 27 ) );
+            os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + 27 ) );
             const std::uint64_t x = json::internal::h_to_be( v );
             os.write( reinterpret_cast< const char* >( &x ), sizeof( x ) );
          }
@@ -88,7 +88,7 @@ namespace tao::json::cbor::events
          std::uint64_t n;
          std::memcpy( &n, &v, sizeof( n ) );
          n = json::internal::h_to_be( n );
-         os.put( char( std::uint8_t( internal::major::OTHER ) + 27 ) );
+         os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::OTHER ) + 27 ) );
          os.write( reinterpret_cast< const char* >( &n ), sizeof( n ) );
       }
 
@@ -106,7 +106,7 @@ namespace tao::json::cbor::events
 
       void begin_array()
       {
-         os.put( char( std::uint8_t( internal::major::ARRAY ) + internal::minor_mask ) );
+         os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::ARRAY ) + internal::minor_mask ) );
       }
 
       void begin_array( const std::size_t size )
@@ -119,15 +119,15 @@ namespace tao::json::cbor::events
 
       void end_array()
       {
-         os.put( char( 0xff ) );
+         os.put( static_cast< char >( 0xff ) );
       }
 
       void end_array( const std::size_t /*unused*/ ) noexcept
       {}
 
       void begin_object()
       {
-         os.put( char( std::uint8_t( internal::major::OBJECT ) + internal::minor_mask ) );
+         os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::OBJECT ) + internal::minor_mask ) );
       }
 
       void begin_object( const std::size_t size )
@@ -145,7 +145,7 @@ namespace tao::json::cbor::events
 
       void end_object()
       {
-         os.put( char( 0xff ) );
+         os.put( static_cast< char >( 0xff ) );
       }
 
       void end_object( const std::size_t /*unused*/ ) noexcept
diff --git a/include/tao/json/cbor/parts_parser.hpp b/include/tao/json/cbor/parts_parser.hpp
@@ -62,10 +62,10 @@ namespace tao::json::cbor
       {
          const auto b = json::internal::peek_uint8( in );
          switch( b ) {
-            case std::uint8_t( major::OTHER ) + 20:
-            case std::uint8_t( major::OTHER ) + 21:
+            case static_cast< std::uint8_t >( major::OTHER ) + 20:
+            case static_cast< std::uint8_t >( major::OTHER ) + 21:
                in.bump_in_this_line( 1 );
-               return bool( b - std::uint8_t( major::OTHER ) - 20 );
+               return static_cast< bool >( b - static_cast< std::uint8_t >( major::OTHER ) - 20 );
             default:
                throw pegtl::parse_error( "expected boolean", in );
          }
@@ -84,8 +84,7 @@ namespace tao::json::cbor
       template< typename... Ts >
       explicit basic_parts_parser( Ts&&... ts )
          : m_input( std::forward< Ts >( ts )... )
-      {
-      }
+      {}
 
       [[nodiscard]] bool empty()
       {
@@ -94,7 +93,7 @@ namespace tao::json::cbor
 
       [[nodiscard]] bool null()
       {
-         if( json::internal::peek_uint8( m_input ) == std::uint8_t( internal::major::OTHER ) + 22 ) {
+         if( json::internal::peek_uint8( m_input ) == static_cast< std::uint8_t >( internal::major::OTHER ) + 22 ) {
             m_input.bump_in_this_line( 1 );
             return true;
          }
@@ -144,7 +143,7 @@ namespace tao::json::cbor
       [[nodiscard]] std::string_view string_view()
       {
          const auto b = json::internal::peek_uint8( m_input );
-         if( b != std::uint8_t( internal::major::STRING ) + internal::minor_mask ) {
+         if( b != static_cast< std::uint8_t >( internal::major::STRING ) + internal::minor_mask ) {
             throw pegtl::parse_error( "expected definitive string", m_input );
          }
          return internal::read_string_1< V, std::string_view >( m_input );
@@ -153,7 +152,7 @@ namespace tao::json::cbor
       [[nodiscard]] tao::binary_view binary_view()
       {
          const auto b = json::internal::peek_uint8( m_input );
-         if( b != std::uint8_t( internal::major::BINARY ) + internal::minor_mask ) {
+         if( b != static_cast< std::uint8_t >( internal::major::BINARY ) + internal::minor_mask ) {
             throw pegtl::parse_error( "expected definitive binary", m_input );
          }
          return internal::read_string_1< utf8_mode::trust, tao::binary_view >( m_input );
@@ -171,7 +170,7 @@ namespace tao::json::cbor
          if( u > 9223372036854775807ULL ) {
             throw pegtl::parse_error( "positive integer overflow", m_input );
          }
-         return std::int64_t( u );
+         return static_cast< std::int64_t >( u );
       }
 
       [[nodiscard]] std::int64_t number_signed_negative()
@@ -180,7 +179,7 @@ namespace tao::json::cbor
          if( u > 9223372036854775808ULL ) {
             throw pegtl::parse_error( "negative integer overflow", m_input );
          }
-         return std::int64_t( ~u );
+         return static_cast< std::int64_t >( ~u );
       }
 
 #if defined( _MSC_VER )
@@ -215,11 +214,11 @@ namespace tao::json::cbor
       {
          const auto b = json::internal::peek_uint8( m_input );
          switch( b ) {
-            case std::uint8_t( internal::major::OTHER ) + 25:
+            case static_cast< std::uint8_t >( internal::major::OTHER ) + 25:
                return internal::read_fp16( m_input );
-            case std::uint8_t( internal::major::OTHER ) + 26:
+            case static_cast< std::uint8_t >( internal::major::OTHER ) + 26:
                return json::internal::read_big_endian_number< float >( m_input + 1 );
-            case std::uint8_t( internal::major::OTHER ) + 27:
+            case static_cast< std::uint8_t >( internal::major::OTHER ) + 27:
                return json::internal::read_big_endian_number< double >( m_input + 1 );
             default:
                throw pegtl::parse_error( "expected floating point number", m_input );
diff --git a/include/tao/json/contrib/deque_traits.hpp b/include/tao/json/contrib/deque_traits.hpp
@@ -5,6 +5,7 @@
 #define TAO_JSON_CONTRIB_DEQUE_TRAITS_HPP
 
 #include <deque>
+#include <vector>
 
 #include "../consume.hpp"
 #include "../forward.hpp"

Original file line number	Diff line number	Diff line change
`@@ -34,35 +34,35 @@ namespace tao::json::cbor::events`
`34`	`34`
`35`	`35`	`void null()`
`36`	`36`	`{`
`37`		`- os.put( char( std::uint8_t( internal::major::OTHER ) + 22 ) );`
	`37`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::OTHER ) + 22 ) );`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`void boolean( const bool v )`
`41`	`41`	`{`
`42`		`- os.put( char( std::uint8_t( internal::major::OTHER ) + 20 + std::uint8_t( v ) ) );`
	`42`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::OTHER ) + 20 + static_cast< std::uint8_t >( v ) ) );`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`void number( const internal::major m, const std::uint64_t v )`
`46`	`46`	`{`
`47`	`47`	`if( v < 24 ) {`
`48`		`- os.put( char( std::uint8_t( m ) + v ) );`
	`48`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + v ) );`
`49`	`49`	`}`
`50`	`50`	`else if( v < 256 ) {`
`51`		`- os.put( char( std::uint8_t( m ) + 24 ) );`
`52`		`- os.put( char( v ) );`
	`51`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + 24 ) );`
	`52`	`+ os.put( static_cast< char >( v ) );`
`53`	`53`	`}`
`54`	`54`	`else if( v < 65536 ) {`
`55`		`- os.put( char( std::uint8_t( m ) + 25 ) );`
`56`		`- const std::uint16_t x = json::internal::h_to_be( std::uint16_t( v ) );`
	`55`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + 25 ) );`
	`56`	`+ const std::uint16_t x = json::internal::h_to_be( static_cast< std::uint16_t >( v ) );`
`57`	`57`	`os.write( reinterpret_cast< const char* >( &x ), sizeof( x ) );`
`58`	`58`	`}`
`59`	`59`	`else if( v < 4294967296ULL ) {`
`60`		`- os.put( char( std::uint8_t( m ) + 26 ) );`
`61`		`- const std::uint32_t x = json::internal::h_to_be( std::uint32_t( v ) );`
	`60`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + 26 ) );`
	`61`	`+ const std::uint32_t x = json::internal::h_to_be( static_cast< std::uint32_t >( v ) );`
`62`	`62`	`os.write( reinterpret_cast< const char* >( &x ), sizeof( x ) );`
`63`	`63`	`}`
`64`	`64`	`else {`
`65`		`- os.put( char( std::uint8_t( m ) + 27 ) );`
	`65`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( m ) + 27 ) );`
`66`	`66`	`const std::uint64_t x = json::internal::h_to_be( v );`
`67`	`67`	`os.write( reinterpret_cast< const char* >( &x ), sizeof( x ) );`
`68`	`68`	`}`
`@@ -88,7 +88,7 @@ namespace tao::json::cbor::events`
`88`	`88`	`std::uint64_t n;`
`89`	`89`	`std::memcpy( &n, &v, sizeof( n ) );`
`90`	`90`	`n = json::internal::h_to_be( n );`
`91`		`- os.put( char( std::uint8_t( internal::major::OTHER ) + 27 ) );`
	`91`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::OTHER ) + 27 ) );`
`92`	`92`	`os.write( reinterpret_cast< const char* >( &n ), sizeof( n ) );`
`93`	`93`	`}`
`94`	`94`
`@@ -106,7 +106,7 @@ namespace tao::json::cbor::events`
`106`	`106`
`107`	`107`	`void begin_array()`
`108`	`108`	`{`
`109`		`- os.put( char( std::uint8_t( internal::major::ARRAY ) + internal::minor_mask ) );`
	`109`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::ARRAY ) + internal::minor_mask ) );`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`void begin_array( const std::size_t size )`
`@@ -119,15 +119,15 @@ namespace tao::json::cbor::events`
`119`	`119`
`120`	`120`	`void end_array()`
`121`	`121`	`{`
`122`		`- os.put( char( 0xff ) );`
	`122`	`+ os.put( static_cast< char >( 0xff ) );`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`void end_array( const std::size_t /unused/ ) noexcept`
`126`	`126`	`{}`
`127`	`127`
`128`	`128`	`void begin_object()`
`129`	`129`	`{`
`130`		`- os.put( char( std::uint8_t( internal::major::OBJECT ) + internal::minor_mask ) );`
	`130`	`+ os.put( static_cast< char >( static_cast< std::uint8_t >( internal::major::OBJECT ) + internal::minor_mask ) );`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`void begin_object( const std::size_t size )`
`@@ -145,7 +145,7 @@ namespace tao::json::cbor::events`
`145`	`145`
`146`	`146`	`void end_object()`
`147`	`147`	`{`
`148`		`- os.put( char( 0xff ) );`
	`148`	`+ os.put( static_cast< char >( 0xff ) );`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`void end_object( const std::size_t /unused/ ) noexcept`
Original file line number	Diff line number	Diff line change
`@@ -62,10 +62,10 @@ namespace tao::json::cbor`
`62`	`62`	`{`
`63`	`63`	`const auto b = json::internal::peek_uint8( in );`
`64`	`64`	`switch( b ) {`
`65`		`- case std::uint8_t( major::OTHER ) + 20:`
`66`		`- case std::uint8_t( major::OTHER ) + 21:`
	`65`	`+ case static_cast< std::uint8_t >( major::OTHER ) + 20:`
	`66`	`+ case static_cast< std::uint8_t >( major::OTHER ) + 21:`
`67`	`67`	`in.bump_in_this_line( 1 );`
`68`		`- return bool( b - std::uint8_t( major::OTHER ) - 20 );`
	`68`	`+ return static_cast< bool >( b - static_cast< std::uint8_t >( major::OTHER ) - 20 );`
`69`	`69`	`default:`
`70`	`70`	`throw pegtl::parse_error( "expected boolean", in );`
`71`	`71`	`}`
`@@ -84,8 +84,7 @@ namespace tao::json::cbor`
`84`	`84`	`template< typename... Ts >`
`85`	`85`	`explicit basic_parts_parser( Ts&&... ts )`
`86`	`86`	`: m_input( std::forward< Ts >( ts )... )`
`87`		`- {`
`88`		`- }`
	`87`	`+ {}`
`89`	`88`
`90`	`89`	`[[nodiscard]] bool empty()`
`91`	`90`	`{`
`@@ -94,7 +93,7 @@ namespace tao::json::cbor`
`94`	`93`
`95`	`94`	`[[nodiscard]] bool null()`
`96`	`95`	`{`
`97`		`- if( json::internal::peek_uint8( m_input ) == std::uint8_t( internal::major::OTHER ) + 22 ) {`
	`96`	`+ if( json::internal::peek_uint8( m_input ) == static_cast< std::uint8_t >( internal::major::OTHER ) + 22 ) {`
`98`	`97`	`m_input.bump_in_this_line( 1 );`
`99`	`98`	`return true;`
`100`	`99`	`}`
`@@ -144,7 +143,7 @@ namespace tao::json::cbor`
`144`	`143`	`[[nodiscard]] std::string_view string_view()`
`145`	`144`	`{`
`146`	`145`	`const auto b = json::internal::peek_uint8( m_input );`
`147`		`- if( b != std::uint8_t( internal::major::STRING ) + internal::minor_mask ) {`
	`146`	`+ if( b != static_cast< std::uint8_t >( internal::major::STRING ) + internal::minor_mask ) {`
`148`	`147`	`throw pegtl::parse_error( "expected definitive string", m_input );`
`149`	`148`	`}`
`150`	`149`	`return internal::read_string_1< V, std::string_view >( m_input );`
`@@ -153,7 +152,7 @@ namespace tao::json::cbor`
`153`	`152`	`[[nodiscard]] tao::binary_view binary_view()`
`154`	`153`	`{`
`155`	`154`	`const auto b = json::internal::peek_uint8( m_input );`
`156`		`- if( b != std::uint8_t( internal::major::BINARY ) + internal::minor_mask ) {`
	`155`	`+ if( b != static_cast< std::uint8_t >( internal::major::BINARY ) + internal::minor_mask ) {`
`157`	`156`	`throw pegtl::parse_error( "expected definitive binary", m_input );`
`158`	`157`	`}`
`159`	`158`	`return internal::read_string_1< utf8_mode::trust, tao::binary_view >( m_input );`
`@@ -171,7 +170,7 @@ namespace tao::json::cbor`
`171`	`170`	`if( u > 9223372036854775807ULL ) {`
`172`	`171`	`throw pegtl::parse_error( "positive integer overflow", m_input );`
`173`	`172`	`}`
`174`		`- return std::int64_t( u );`
	`173`	`+ return static_cast< std::int64_t >( u );`
`175`	`174`	`}`
`176`	`175`
`177`	`176`	`[[nodiscard]] std::int64_t number_signed_negative()`
`@@ -180,7 +179,7 @@ namespace tao::json::cbor`
`180`	`179`	`if( u > 9223372036854775808ULL ) {`
`181`	`180`	`throw pegtl::parse_error( "negative integer overflow", m_input );`
`182`	`181`	`}`
`183`		`- return std::int64_t( ~u );`
	`182`	`+ return static_cast< std::int64_t >( ~u );`
`184`	`183`	`}`
`185`	`184`
`186`	`185`	`#if defined( _MSC_VER )`
`@@ -215,11 +214,11 @@ namespace tao::json::cbor`
`215`	`214`	`{`
`216`	`215`	`const auto b = json::internal::peek_uint8( m_input );`
`217`	`216`	`switch( b ) {`
`218`		`- case std::uint8_t( internal::major::OTHER ) + 25:`
	`217`	`+ case static_cast< std::uint8_t >( internal::major::OTHER ) + 25:`
`219`	`218`	`return internal::read_fp16( m_input );`
`220`		`- case std::uint8_t( internal::major::OTHER ) + 26:`
	`219`	`+ case static_cast< std::uint8_t >( internal::major::OTHER ) + 26:`
`221`	`220`	`return json::internal::read_big_endian_number< float >( m_input + 1 );`
`222`		`- case std::uint8_t( internal::major::OTHER ) + 27:`
	`221`	`+ case static_cast< std::uint8_t >( internal::major::OTHER ) + 27:`
`223`	`222`	`return json::internal::read_big_endian_number< double >( m_input + 1 );`
`224`	`223`	`default:`
`225`	`224`	`throw pegtl::parse_error( "expected floating point number", m_input );`