More clang tidy

.clang-tidy

@@ -27,7 +27,9 @@ Checks: >
   -misc-non-private-member-variables-in-classes,
   -misc-no-recursion,
   performance-*,
+  -performance-avoid-endl,
   readability-*,
+  -readability-avoid-nested-conditional-operator,
   -readability-function-cognitive-complexity,
   -readability-function-size,
   -readability-identifier-length,

src/extension/NetworkController.hpp

@@ -50,10 +50,10 @@ namespace extension {
 
     private:
         /// Our NUClearNetwork object that handles the networking
-        network::NUClearNetwork network{};
+        network::NUClearNetwork network;
 
         /// The reaction that handles timed events from the network
-        ReactionHandle process_handle{};
+        ReactionHandle process_handle;
         /// The reactions that listen for io
         std::vector<ReactionHandle> listen_handles;
 

src/extension/network/NUClearNetwork.hpp

@@ -67,7 +67,7 @@ namespace extension {
                 /// The socket address for the remote target
                 sock_t target{};
                 /// When we last received data from the remote target
-                std::chrono::steady_clock::time_point last_update{};
+                std::chrono::steady_clock::time_point last_update;
                 /// A list of the last n packet groups to be received
                 std::array<int, std::numeric_limits<uint8_t>::max()> recent_packets{};
                 /// An index for the recent_packets (circular buffer)
@@ -77,7 +77,7 @@ namespace extension {
                 /// Storage for fragmented packets while we build them
                 std::map<uint16_t,
                          std::pair<std::chrono::steady_clock::time_point, std::map<uint16_t, std::vector<uint8_t>>>>
-                    assemblers{};
+                    assemblers;
 
                 /// Struct storing the kalman filter for round trip time
                 struct RoundTripKF {
@@ -215,23 +215,23 @@ namespace extension {
                     PacketTarget(std::weak_ptr<NetworkTarget> target, std::vector<uint8_t> acked);
 
                     /// The target we are sending this packet to
-                    std::weak_ptr<NetworkTarget> target{};
+                    std::weak_ptr<NetworkTarget> target;
 
                     /// The bitset of the packets that have been acked
                     std::vector<uint8_t> acked;
 
                     /// When we last sent data to this client
-                    std::chrono::steady_clock::time_point last_send{};
+                    std::chrono::steady_clock::time_point last_send;
                 };
 
                 /// Default constructor for the PacketQueue
                 PacketQueue();
 
                 /// The remote targets that want this packet
-                std::list<PacketTarget> targets{};
+                std::list<PacketTarget> targets;
 
                 /// The header of the packet to send
-                DataPacket header{};
+                DataPacket header;
 
                 /// The data to send
                 std::vector<uint8_t> payload;

src/threading/ReactionTask.cpp

@@ -51,9 +51,10 @@ namespace threading {
             // Run our callback
             callback(*this);
         }
-        catch (...) {
+        catch (...) {  // NOLINT(bugprone-empty-catch)
             // This shouldn't happen, but either way no exceptions should ever leave this function
-            // They should have all been caught and callback is noexcept, however it seems that's a suggestion
+            // They should have all been caught and callback is noexcept
+            // However somehow it still happens sometimes so we need to catch it
         }
 
         // Restore the current task

src/util/apply.hpp

@@ -48,7 +48,7 @@ namespace util {
 
         // Get each of the values from the tuple, dereference them and call the function with them
         // Also ensure that each value is a const reference
-        function(Dereferencer<decltype(std::get<S>(args))>(std::get<S>(args))...);
+        std::forward<Function>(function)(Dereferencer<decltype(std::get<S>(args))>(std::get<S>(args))...);
     }
 
     template <typename Function, typename... Arguments>

tests/tests/api/ReactorArgs.cpp

@@ -30,7 +30,7 @@ class TestReactorNoArgs : public NUClear::Reactor {
 public:
     TestReactorNoArgs(std::unique_ptr<NUClear::Environment> environment) : NUClear::Reactor(std::move(environment)) {}
 
-    std::string s{};
+    std::string s;
     bool b{false};
     uint32_t i{0};
 };
@@ -39,7 +39,7 @@ class TestReactorArgs : public NUClear::Reactor {
     TestReactorArgs(std::unique_ptr<NUClear::Environment> environment, std::string s, const bool& b, const uint32_t& i)
         : NUClear::Reactor(std::move(environment)), s(std::move(s)), b(b), i(i) {}
 
-    std::string s{};
+    std::string s;
     bool b{false};
     uint32_t i{0};
 };

tests/tests/dsl/UDP.cpp

@@ -31,7 +31,7 @@ namespace {
 /// Events that occur during the test
 std::vector<std::string> events;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-enum TestPorts {
+enum TestPorts : uint16_t {
     UNICAST_V4   = 40000,
     UNICAST_V6   = 40001,
     BROADCAST_V4 = 40002,
@@ -59,7 +59,7 @@ in_port_t broad_v4_port = 0;  // NOLINT(cppcoreguidelines-avoid-non-const-global
 in_port_t multi_v4_port = 0;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 in_port_t multi_v6_port = 0;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-enum TestType {
+enum TestType : uint8_t {
     UNICAST_V4_KNOWN,
     UNICAST_V4_EPHEMERAL,
     UNICAST_V6_KNOWN,

tests/tests/threading/CountingLock.cpp

@@ -33,8 +33,8 @@ namespace threading {
             "The last lock to attempt a lock which hits the target value should obtain the lock"
             "[threading][scheduler][CountingLock]") {
 
-            int base   = GENERATE(-1, 1, 2);
-            int offset = GENERATE(-1, 0, 1);
+            const int base   = GENERATE(-1, 1, 2);
+            const int offset = GENERATE(-1, 0, 1);
 
             GIVEN("An atomic integer with a value of 2") {
                 std::atomic<int> active{2 * base + offset};