fix clang-tidy warnings

Author: bkueng

.clang-tidy

@@ -12,6 +12,7 @@ Checks: >
   -google-readability-todo,
   -google-readability-namespace-comments,
   -google-runtime-references,
+  -misc-include-cleaner,
   -misc-non-private-member-variables-in-classes,
   -misc-unused-parameters,
   -misc-no-recursion,
@@ -21,6 +22,7 @@ Checks: >
   -modernize-avoid-c-arrays,
   -modernize-use-auto,
   -modernize-use-nodiscard,
+  -performance-enum-size,
   -performance-move-const-arg,
   -readability-braces-around-statements,
   -readability-identifier-length,

.cppcheck-suppress

@@ -4,4 +4,5 @@ unusedFunction
 useStlAlgorithm
 noExplicitConstructor
 unusedStructMember
+normalCheckLevelMaxBranches
 *:*_deps/*

cmake/clang_format.cmake

@@ -21,7 +21,7 @@ add_custom_target(
 	clang-tidy
 	COMMAND ${PROJECT_SOURCE_DIR}/tools/run-clang-tidy.py
 		-p . -use-color -header-filter='.*' -quiet
-		-extra-arg=-std=c++17
+		-extra-arg=-std=c++17 -extra-arg=-Wno-unknown-warning-option
 		-ignore ${PROJECT_SOURCE_DIR}/.clang-tidy-ignore
 	WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
 	USES_TERMINAL

examples/ulog_writer.cpp

@@ -10,12 +10,14 @@
 
 using namespace std::chrono_literals;
 
-static uint64_t currentTimeUs()
+namespace {
+uint64_t currentTimeUs()
 {
   return std::chrono::duration_cast<std::chrono::microseconds>(
              std::chrono::steady_clock::now().time_since_epoch())
       .count();
 }
+}  // namespace
 
 struct MyData {
   uint64_t timestamp;

test/ulog_parsing_test.cpp

@@ -108,8 +108,9 @@ TEST_CASE("ULog parsing - basic test: write then read")
   }
 }
 
-static void readFileWriteTest(const std::filesystem::path& path,
-                              const std::function<unsigned()>& next_chunk_size)
+namespace {
+void readFileWriteTest(const std::filesystem::path& path,
+                       const std::function<unsigned()>& next_chunk_size)
 {
   FILE* file = fopen(path.c_str(), "rb");
   CHECK(file);
@@ -144,6 +145,7 @@ static void readFileWriteTest(const std::filesystem::path& path,
   CHECK_EQ(input_data.size(), written_data.size());
   CHECK_EQ(input_data, written_data);
 }
+}  // namespace
 
 TEST_CASE("ULog parsing - read sample files then write")
 {
@@ -343,7 +345,7 @@ TEST_CASE("ULog parsing - simple writer")
   std::vector<MyData> written_data_messages;
   for (int i = 0; i < 100; ++i) {
     MyData data{};
-    data.timestamp = i * 1000;
+    data.timestamp = static_cast<uint64_t>(i) * 1000;
     data.cpuload = cpuload;
     data.counter = i;
     writer.writeData(my_data_msg_id, data);

ulog_cpp/messages.cpp

@@ -196,7 +196,7 @@ Value::NativeTypeVariant Value::asNativeTypeVariant() const
   if (_field_ref.arrayLength() == -1 || _array_index >= 0) {
     // decode as a single value. Either it is a single value,
     // or the user has explicitly selected an array element
-    int array_offset = _array_index >= 0 ? _array_index : 0;
+    const int array_offset = _array_index >= 0 ? _array_index : 0;
     switch (_field_ref.type().type) {
       case Field::BasicType::INT8:
         return deserialize<int8_t>(_backing_ref_begin, _backing_ref_end,
@@ -298,8 +298,8 @@ Value Value::operator[](const Field& field) const
   if (!_field_ref.definitionResolved()) {
     throw AccessException("Cannot access field of unresolved type");
   }
-  int submessage_offset = _field_ref.offsetInMessage() +
-                          ((_array_index >= 0) ? _field_ref.type().size * _array_index : 0);
+  const int submessage_offset = _field_ref.offsetInMessage() +
+                                ((_array_index >= 0) ? _field_ref.type().size * _array_index : 0);
 
   return Value(field, _backing_ref_begin + submessage_offset, _backing_ref_end);
 }

ulog_cpp/messages.hpp

@@ -172,25 +172,25 @@ class Field {
    * @brief Get the type attributes of the field
    * @return The type attributes
    */
-  inline const TypeAttributes& type() const { return _type; }
+  const TypeAttributes& type() const { return _type; }
 
   /**
    * @brief Get the array length of the field
    * @return The array length, -1 if not an array
    */
-  inline int arrayLength() const { return _array_length; }
+  int arrayLength() const { return _array_length; }
 
   /**
    * @brief Get the offset of the field in the message. This is only valid if the field is resolved.
    * @return The offset in bytes, -1 if not resolved
    */
-  inline int offsetInMessage() const { return _offset_in_message_bytes; }
+  int offsetInMessage() const { return _offset_in_message_bytes; }
 
   /**
    * @brief Get the name of the field
    * @return The name
    */
-  inline const std::string& name() const { return _name; }
+  const std::string& name() const { return _name; }
 
   /**
    * @brief Get the size of the field in bytes. This is only valid if the field is resolved.
@@ -203,11 +203,11 @@ class Field {
    * is defined and the type is not nested or the nested message is resolved.
    * @return True if the field is resolved
    */
-  inline bool definitionResolved() const
+  bool definitionResolved() const
   {
     return _offset_in_message_bytes >= 0 &&
            (_type.type != BasicType::NESTED || _type.nested_message != nullptr);
-  };
+  }
 
   /**
    * @brief Attempt to resolve the definition of the field.
@@ -353,8 +353,8 @@ class Value {
             // this is natively a vector
             if constexpr (is_vector<ReturnType>::value) {
               // return type is also vector
-              if constexpr (std::is_same<typename NativeType::value_type,
-                                         typename ReturnType::value_type>::value) {
+              if constexpr (std::is_same_v<typename NativeType::value_type,
+                                           typename ReturnType::value_type>) {
                 // return type is same as native type
                 res = arg;
               } else {
@@ -428,7 +428,7 @@ class Value {
                        int array_offset)
   {
     T v;
-    int total_offset = offset + array_offset * sizeof(T);
+    const int total_offset = offset + (array_offset * sizeof(T));
     if (backing_start > backing_end ||
         backing_end - backing_start < static_cast<int64_t>(sizeof(v)) + total_offset) {
       throw AccessException("Unexpected data type size");
@@ -603,6 +603,7 @@ class MessageFormat {
   std::vector<std::string> fieldNames() const
   {
     std::vector<std::string> names;
+    names.reserve(_fields_ordered.size());
     for (const auto& field_it : _fields_ordered) {
       names.push_back(field_it->name());
     }

ulog_cpp/reader.cpp

@@ -9,7 +9,7 @@
 
 #include "raw_messages.hpp"
 
-#if 0
+#if 0  // NOLINT (readability-avoid-unconditional-preprocessor-if)
 #define DBG_PRINTF(...) printf(__VA_ARGS__)
 #else
 #define DBG_PRINTF(...)