fix: remediate batch 4 clang-tidy violations

include/events/event_types.h

@@ -81,7 +81,7 @@ struct EventSubscription {
     std::chrono::milliseconds cycle_time{0};  // For periodic events
     std::chrono::steady_clock::time_point last_notification{std::chrono::steady_clock::now()};
 
-    EventSubscription(uint16_t svc_id = 0, uint16_t inst_id = 0, uint16_t evt_id = 0, uint16_t eg_id = 0)
+    explicit EventSubscription(uint16_t svc_id = 0, uint16_t inst_id = 0, uint16_t evt_id = 0, uint16_t eg_id = 0)
         : service_id(svc_id), instance_id(inst_id), event_id(evt_id), eventgroup_id(eg_id) {
         last_notification = std::chrono::steady_clock::now();
     }
@@ -99,7 +99,7 @@ struct EventNotification {
     std::vector<uint8_t> event_data;
     std::chrono::steady_clock::time_point timestamp{std::chrono::steady_clock::now()};
 
-    EventNotification(uint16_t svc_id = 0, uint16_t inst_id = 0, uint16_t evt_id = 0)
+    explicit EventNotification(uint16_t svc_id = 0, uint16_t inst_id = 0, uint16_t evt_id = 0)
         : service_id(svc_id), instance_id(inst_id), event_id(evt_id) {
         timestamp = std::chrono::steady_clock::now();
     }

include/sd/sd_message.h

@@ -24,7 +24,7 @@ namespace someip::sd {
 /** @implements REQ_SD_200A, REQ_SD_200B, REQ_SD_200C */
 class SdEntry {
 public:
-    SdEntry(EntryType type, uint32_t ttl = 0)
+    explicit SdEntry(EntryType type, uint32_t ttl = 0)
         : type_(type), ttl_(ttl) {}
 
     virtual ~SdEntry() = default;
@@ -58,7 +58,7 @@ class SdEntry {
 /** @implements REQ_SD_200B */
 class ServiceEntry : public SdEntry {
 public:
-    ServiceEntry(EntryType type = EntryType::FIND_SERVICE)
+    explicit ServiceEntry(EntryType type = EntryType::FIND_SERVICE)
         : SdEntry(type) {}
 
     uint16_t get_service_id() const { return service_id_; }
@@ -88,7 +88,7 @@ class ServiceEntry : public SdEntry {
  */
 class EventGroupEntry : public SdEntry {
 public:
-    EventGroupEntry(EntryType type = EntryType::SUBSCRIBE_EVENTGROUP)
+    explicit EventGroupEntry(EntryType type = EntryType::SUBSCRIBE_EVENTGROUP)
         : SdEntry(type) {}
 
     uint16_t get_service_id() const { return service_id_; }
@@ -118,7 +118,7 @@ class EventGroupEntry : public SdEntry {
  */
 class SdOption {
 public:
-    SdOption(OptionType type) : type_(type) {}
+    explicit SdOption(OptionType type) : type_(type) {}
     virtual ~SdOption() = default;
 
     OptionType get_type() const { return type_; }

include/sd/sd_types.h

@@ -68,7 +68,7 @@ struct ServiceInstance {
     uint8_t protocol{0x11};  // Default to UDP (0x11)
     uint32_t ttl_seconds{0};  // Time to live
 
-    ServiceInstance(uint16_t svc_id = 0, uint16_t inst_id = 0,
+    explicit ServiceInstance(uint16_t svc_id = 0, uint16_t inst_id = 0,
                    uint8_t maj_ver = 0, uint8_t min_ver = 0)
         : service_id(svc_id), instance_id(inst_id),
           major_version(maj_ver), minor_version(min_ver) {}
@@ -81,7 +81,7 @@ struct EventGroup {
     uint8_t minor_version{0};
     std::vector<uint16_t> event_ids;
 
-    EventGroup(uint16_t eg_id = 0, uint8_t maj_ver = 0, uint8_t min_ver = 0)
+    explicit EventGroup(uint16_t eg_id = 0, uint8_t maj_ver = 0, uint8_t min_ver = 0)
         : eventgroup_id(eg_id), major_version(maj_ver), minor_version(min_ver) {}
 };
 
@@ -125,7 +125,7 @@ struct EventGroupSubscription {
     SubscriptionState state{SubscriptionState::REQUESTED};
     std::chrono::steady_clock::time_point timestamp{std::chrono::steady_clock::now()};
 
-    EventGroupSubscription(uint16_t svc_id = 0, uint16_t inst_id = 0, uint16_t eg_id = 0)
+    explicit EventGroupSubscription(uint16_t svc_id = 0, uint16_t inst_id = 0, uint16_t eg_id = 0)
         : service_id(svc_id), instance_id(inst_id), eventgroup_id(eg_id) {
         timestamp = std::chrono::steady_clock::now();
     }

src/common/result.cpp

@@ -10,7 +10,7 @@ namespace someip {
  */
 /** @implements REQ_ARCH_004, REQ_MY_001 */
 std::string to_string(Result result) {
-    static const std::unordered_map<Result, std::string> result_strings = {
+    static const std::unordered_map<Result, std::string> RESULT_STRINGS = {
         {Result::SUCCESS, "SUCCESS"},
         {Result::NETWORK_ERROR, "NETWORK_ERROR"},
         {Result::NOT_CONNECTED, "NOT_CONNECTED"},
@@ -46,8 +46,8 @@ std::string to_string(Result result) {
         {Result::UNKNOWN_ERROR, "UNKNOWN_ERROR"}
     };
 
-    auto it = result_strings.find(result);
-    return (it != result_strings.end()) ? it->second : "UNKNOWN_RESULT";
+    const auto it = RESULT_STRINGS.find(result);
+    return (it != RESULT_STRINGS.end()) ? it->second : "UNKNOWN_RESULT";
 }
 
 } // namespace someip

src/e2e/e2e_profiles/standard_profile.cpp

@@ -246,7 +246,7 @@ class BasicE2EProfile : public E2EProfile {
             auto now = std::chrono::steady_clock::now();
             auto ms_now = std::chrono::duration_cast<std::chrono::milliseconds>(
                 now.time_since_epoch()).count();
-            uint16_t current_freshness = static_cast<uint16_t>(ms_now & 0xFFFF);
+            auto current_freshness = static_cast<uint16_t>(ms_now & 0xFFFF);
 
             // Calculate freshness difference (handle wrap-around)
             // Since we're using 16-bit values, we need to handle wrap-around
@@ -264,7 +264,7 @@ class BasicE2EProfile : public E2EProfile {
             // Convert timeout to 16-bit units (approximately)
             // Since we're storing lower 16 bits of milliseconds,
             // we compare against timeout_ms directly (assuming timeout < 65535 ms)
-            uint16_t const timeout_units = static_cast<uint16_t>(config.freshness_timeout_ms);
+            auto const timeout_units = static_cast<uint16_t>(config.freshness_timeout_ms);
             if (freshness_diff > timeout_units && freshness_diff < (0xFFFF - timeout_units)) {
                 // If difference is large and not due to wrap-around, it's stale
                 return Result::TIMEOUT;  // Stale data

src/platform/freertos/memory.cpp

@@ -21,6 +21,8 @@
 #include <semphr.h>
 #include <task.h>
 
+#include <algorithm>
+#include <array>
 #include <atomic>
 #include <cstdint>
 #include <cstring>
@@ -34,10 +36,10 @@ static constexpr size_t POOL_SIZE = SOMEIP_FREERTOS_MESSAGE_POOL_SIZE;
 
 namespace {
 
-alignas(someip::Message) char
-    pool_buffer[POOL_SIZE * sizeof(someip::Message)];
+alignas(someip::Message) std::array<char, POOL_SIZE * sizeof(someip::Message)>
+    pool_buffer{};
 
-bool block_used[POOL_SIZE] = {};
+std::array<bool, POOL_SIZE> block_used{};
 SemaphoreHandle_t pool_mutex = nullptr;
 std::atomic<bool> pool_initialized{false};
 
@@ -52,7 +54,7 @@ void ensure_pool_init() {
         pool_mutex = xSemaphoreCreateMutex();
         configASSERT(pool_mutex != nullptr);
         if (pool_mutex != nullptr) {
-            std::memset(block_used, 0, sizeof(block_used));
+            std::fill(block_used.begin(), block_used.end(), false);
             pool_initialized.store(true, std::memory_order_release);
         }
     }
@@ -66,7 +68,7 @@ void release_message_impl(someip::Message* msg) {
     }
 
     auto raw_addr = reinterpret_cast<std::uintptr_t>(msg);
-    auto pool_addr = reinterpret_cast<std::uintptr_t>(pool_buffer);
+    auto pool_addr = reinterpret_cast<std::uintptr_t>(pool_buffer.data());
     if (raw_addr < pool_addr || raw_addr >= pool_addr + POOL_SIZE * sizeof(someip::Message)) {
         return;
     }
@@ -98,7 +100,7 @@ MessagePtr allocate_message() {
             block_used[i] = true;
             xSemaphoreGive(pool_mutex);
 
-            void* block = pool_buffer + i * sizeof(Message);
+            void* block = pool_buffer.data() + i * sizeof(Message);
             auto* msg = new (block) Message();
             return MessagePtr(msg, [](Message* p) {
                 release_message(p);

src/platform/threadx/memory.cpp

@@ -20,6 +20,7 @@
 
 #include <tx_api.h>
 
+#include <array>
 #include <atomic>
 #include <cstring>
 #include <new>
@@ -35,8 +36,8 @@ std::atomic<bool> pool_initialized{false};
 
 namespace {
 
-alignas(someip::Message) UCHAR
-    pool_buffer[POOL_SIZE * sizeof(someip::Message)];
+alignas(someip::Message) std::array<UCHAR, POOL_SIZE * sizeof(someip::Message)>
+    pool_buffer{};
 
 TX_MUTEX pool_guard;
 
@@ -56,7 +57,7 @@ void ensure_pool_init() {
             status = tx_block_pool_create(&message_pool,
                                           const_cast<CHAR*>("someip_msg"),
                                           sizeof(someip::Message),
-                                          pool_buffer,
+                                          pool_buffer.data(),
                                           sizeof(pool_buffer));
             if (status != TX_SUCCESS) {
                 tx_mutex_delete(&pool_guard);

src/rpc/rpc_server.cpp

@@ -126,7 +126,7 @@ class RpcServerImpl : public transport::ITransportListener {
         MethodHandler handler;
         {
             platform::ScopedLock const lock(methods_mutex_);
-            auto it = method_handlers_.find(message->get_method_id());
+            const auto it = method_handlers_.find(message->get_method_id());
             if (it == method_handlers_.end()) {
                 // Method not found - send error response
                 send_error_response(message, sender, ReturnCode::E_UNKNOWN_METHOD);
@@ -163,24 +163,24 @@ class RpcServerImpl : public transport::ITransportListener {
     /** @implements REQ_MSG_115, REQ_MSG_117, REQ_MSG_117_E01 */
     void send_success_response(MessagePtr const& request, const transport::Endpoint& sender,
                               const std::vector<uint8_t>& return_values) {
-        MessageId response_msg_id(request->get_service_id(), request->get_method_id());
+        const MessageId response_msg_id(request->get_service_id(), request->get_method_id());
         Message response(response_msg_id, request->get_request_id(),
                         MessageType::RESPONSE, ReturnCode::E_OK);
         response.set_payload(return_values);
 
-        Result result = transport_->send_message(response, sender);
+        const Result result = transport_->send_message(response, sender);
         if (result != Result::SUCCESS) {
             // Log error or handle send failure
         }
     }
 
     /** @implements REQ_MSG_115, REQ_MSG_117, REQ_MSG_117_E01, REQ_MSG_129 */
     void send_error_response(MessagePtr const& request, const transport::Endpoint& sender, ReturnCode error_code) {
-        MessageId response_msg_id(request->get_service_id(), request->get_method_id());
+        const MessageId response_msg_id(request->get_service_id(), request->get_method_id());
         Message response(response_msg_id, request->get_request_id(),
                         MessageType::ERROR, error_code);
 
-        Result result = transport_->send_message(response, sender);
+        const Result result = transport_->send_message(response, sender);
         if (result != Result::SUCCESS) {
             // Log error or handle send failure
         }

src/sd/sd_client.cpp

@@ -126,7 +126,7 @@ class SdClientImpl : public transport::ITransportListener {
         someip_message.set_payload(sd_message.serialize());
 
         // Send multicast find message
-        transport::Endpoint multicast_endpoint(config_.multicast_address, config_.multicast_port);
+        transport::Endpoint const multicast_endpoint(config_.multicast_address, config_.multicast_port);
         if (transport_->send_message(someip_message, multicast_endpoint) != Result::SUCCESS) {
             return false;
         }
@@ -204,7 +204,7 @@ class SdClientImpl : public transport::ITransportListener {
         someip_message.set_payload(sd_message.serialize());
 
         // Send multicast message
-        transport::Endpoint multicast_endpoint(config_.multicast_address, config_.multicast_port);
+        transport::Endpoint const multicast_endpoint(config_.multicast_address, config_.multicast_port);
         return transport_->send_message(someip_message, multicast_endpoint) == Result::SUCCESS;
     }
 
@@ -233,7 +233,7 @@ class SdClientImpl : public transport::ITransportListener {
         someip_message.set_payload(sd_message.serialize());
 
         // Send multicast message
-        transport::Endpoint multicast_endpoint(config_.multicast_address, config_.multicast_port);
+        transport::Endpoint const multicast_endpoint(config_.multicast_address, config_.multicast_port);
         return transport_->send_message(someip_message, multicast_endpoint) == Result::SUCCESS;
     }
 
@@ -273,7 +273,7 @@ class SdClientImpl : public transport::ITransportListener {
     };
 
     bool join_multicast_group() {
-        auto udp_transport = std::dynamic_pointer_cast<transport::UdpTransport>(transport_);
+        const auto udp_transport = std::dynamic_pointer_cast<transport::UdpTransport>(transport_);
         if (!udp_transport) {
             return false;
         }
@@ -282,7 +282,7 @@ class SdClientImpl : public transport::ITransportListener {
     }
 
     void leave_multicast_group() {
-        auto udp_transport = std::dynamic_pointer_cast<transport::UdpTransport>(transport_);
+        const auto udp_transport = std::dynamic_pointer_cast<transport::UdpTransport>(transport_);
         if (udp_transport) {
             udp_transport->leave_multicast_group(config_.multicast_address);
         }
@@ -363,7 +363,7 @@ class SdClientImpl : public transport::ITransportListener {
 
         {
             platform::ScopedLock const lock(available_services_mutex_);
-            auto it = std::find_if(available_services_.begin(), available_services_.end(),
+            const auto it = std::find_if(available_services_.begin(), available_services_.end(),
                 [&](const ServiceInstance& svc) {
                     return svc.service_id == instance.service_id &&
                            svc.instance_id == instance.instance_id;
@@ -404,7 +404,7 @@ class SdClientImpl : public transport::ITransportListener {
             avail_cb(instance);
         }
         for (const auto& cb : find_cbs) {
-            std::vector<ServiceInstance> found_services = {instance};
+            const std::vector<ServiceInstance> found_services = {instance};
             cb(found_services);
         }
     }
@@ -417,7 +417,7 @@ class SdClientImpl : public transport::ITransportListener {
 
         {
             platform::ScopedLock const lock(available_services_mutex_);
-            auto it = std::remove_if(available_services_.begin(), available_services_.end(),
+            const auto it = std::remove_if(available_services_.begin(), available_services_.end(),
                 [&](const ServiceInstance& svc) {
                     return svc.service_id == instance.service_id &&
                            svc.instance_id == instance.instance_id;