squash! squash! fixup! squash! fixup! fixup! fixup! fixup! fixup! fixup! fixup! fixup! fixup! Code Quality: Address shadowing

Removed explicit template from unique_ptr throughout codebase

Author: kheaactua

.gitignore

@@ -23,3 +23,4 @@
 /Testing
 /logs
 !build_qnx/*
+CMakeUserPresets.json

examples/hello_world/hello_world_service.hpp

@@ -79,7 +79,7 @@ class hello_world_service {
 
     void stop()
     {
-        std::unique_lock<std::mutex> its_lock(mutex_);
+        std::unique_lock its_lock{mutex_};
         while(!stop_) {
             condition_.wait(its_lock);
         }

examples/notify-sample.cpp

@@ -153,7 +153,7 @@ class service_sample {
     }
 
     void run() {
-        std::unique_lock<std::mutex> its_lock(mutex_);
+        std::unique_lock its_lock{mutex_};
         while (!blocked_)
             condition_.wait(its_lock);
 
@@ -177,7 +177,7 @@ class service_sample {
         uint32_t its_size = 1;
 
         while (running_) {
-            std::unique_lock<std::mutex> its_lock(notify_mutex_);
+            std::unique_lock its_lock{notify_mutex_};
             while (!is_offered_ && running_)
                 notify_condition_.wait(its_lock);
             while (is_offered_ && running_) {

examples/request-sample.cpp

@@ -151,7 +151,7 @@ class client_sample {
     void run() {
         while (running_) {
             {
-                std::unique_lock<std::mutex> its_lock(mutex_);
+                std::unique_lock its_lock{mutex_};
                 while (!blocked_) condition_.wait(its_lock);
                 if (is_available_) {
                     app_->send(request_);

examples/response-sample.cpp

@@ -116,7 +116,7 @@ class service_sample {
     }
 
     void run() {
-        std::unique_lock<std::mutex> its_lock(mutex_);
+        std::unique_lock its_lock{mutex_};
         while (!blocked_)
             condition_.wait(its_lock);
 

implementation/configuration/src/configuration_impl.cpp

@@ -3048,7 +3048,7 @@ const std::string & configuration_impl::get_logfile() const {
 }
 
 vsomeip_v3::logger::level_e configuration_impl::get_loglevel() const {
-    std::unique_lock<std::mutex> its_lock(mutex_loglevel_);
+    std::unique_lock its_lock{mutex_loglevel_};
     return loglevel_;
 }
 

implementation/endpoints/src/endpoint_manager_impl.cpp

@@ -981,7 +981,7 @@ bool endpoint_manager_impl::on_bind_error(std::shared_ptr<endpoint> _endpoint,
                     uint16_t its_old_local_port = _endpoint->get_local_port();
                     uint16_t its_new_local_port(ILLEGAL_PORT);
 
-                    std::unique_lock<std::mutex> its_lock(used_client_ports_mutex_);
+                    std::unique_lock its_lock{used_client_ports_mutex_};
                     std::map<bool, std::set<port_t> > its_used_client_ports;
                     get_used_client_ports(_remote_address, _remote_port, its_used_client_ports);
                     if (configuration_->get_client_port(
@@ -1364,7 +1364,7 @@ bool endpoint_manager_impl::check_options_queue() {
 void
 endpoint_manager_impl::process_multicast_options() {
 
-    std::unique_lock<std::mutex> its_lock(options_mutex_);
+    std::unique_lock its_lock{options_mutex_};
     while (is_processing_options_) {
         options_condition_.wait(
                 its_lock, [this] { return check_options_queue() || !is_processing_options_; });

implementation/endpoints/src/local_tcp_client_endpoint_impl.cpp

@@ -125,7 +125,7 @@ void local_tcp_client_endpoint_impl::stop() {
 
 void local_tcp_client_endpoint_impl::connect() {
     boost::system::error_code its_connect_error;
-    std::unique_lock<std::mutex> its_lock(socket_mutex_);
+    std::unique_lock its_lock{socket_mutex_};
     boost::system::error_code its_error;
     socket_->open(remote_.protocol(), its_error);
     if (!its_error || its_error == boost::asio::error::already_open) {

implementation/endpoints/src/local_tcp_server_endpoint_impl.cpp

@@ -248,7 +248,7 @@ void local_tcp_server_endpoint_impl::accept_cbk(
     if (!_error) {
         boost::system::error_code its_error;
         {
-            std::unique_lock<std::mutex> its_socket_lock(_connection->get_socket_lock());
+            std::unique_lock its_socket_lock{_connection->get_socket_lock()};
             auto& new_connection_socket = _connection->get_socket();
 
             endpoint_type remote = new_connection_socket.remote_endpoint(its_error);
@@ -930,7 +930,7 @@ void local_tcp_server_endpoint_impl::print_status() {
 
         std::size_t its_recv_size(0);
         {
-            std::unique_lock<std::mutex> c_s_lock(c.second->get_socket_lock());
+            std::unique_lock c_s_lock{c.second->get_socket_lock()};
             its_recv_size = c.second->get_recv_buffer_capacity();
         }
 

implementation/endpoints/src/local_uds_client_endpoint_impl.cpp

@@ -57,7 +57,7 @@ void local_uds_client_endpoint_impl::restart(bool _force) {
         is_sending_ = false;
     }
     {
-        std::lock_guard<std::mutex> its_lock(socket_mutex_);
+        std::scoped_lock its_lock(socket_mutex_);
         shutdown_and_close_socket_unlocked(true);
     }
     state_ = cei_state_e::CONNECTING;
@@ -78,18 +78,18 @@ void local_uds_client_endpoint_impl::start() {
 
 void local_uds_client_endpoint_impl::stop() {
     {
-        std::lock_guard<std::recursive_mutex> its_lock(mutex_);
+        std::scoped_lock its_lock(mutex_);
         sending_blocked_ = true;
     }
     {
-        std::lock_guard<std::mutex> its_lock(connect_timer_mutex_);
+        std::scoped_lock its_lock(connect_timer_mutex_);
         connect_timer_.cancel();
     }
     connect_timeout_ = VSOMEIP_DEFAULT_CONNECT_TIMEOUT;
 
     bool is_open(false);
     {
-        std::lock_guard<std::mutex> its_lock(socket_mutex_);
+        std::scoped_lock its_lock(socket_mutex_);
         is_open = socket_->is_open();
     }
     if (is_open) {
@@ -116,7 +116,7 @@ void local_uds_client_endpoint_impl::connect() {
     start_connecting_timer();
     boost::system::error_code its_connect_error;
     {
-        std::lock_guard<std::mutex> its_lock(socket_mutex_);
+        std::lock_guard its_lock(socket_mutex_);
         boost::system::error_code its_error;
         socket_->open(remote_.protocol(), its_error);
 
@@ -153,7 +153,7 @@ void local_uds_client_endpoint_impl::connect() {
     }
     std::size_t operations_cancelled;
     {
-        std::lock_guard<std::mutex> its_lock(connecting_timer_mutex_);
+        std::lock_guard its_lock(connecting_timer_mutex_);
         operations_cancelled = connecting_timer_.cancel();
         connecting_timer_state_ = connecting_timer_state_e::FINISH_ERROR;
         if (operations_cancelled != 0) {
@@ -174,7 +174,7 @@ void local_uds_client_endpoint_impl::connect() {
 }
 
 void local_uds_client_endpoint_impl::receive() {
-    std::lock_guard<std::mutex> its_lock(socket_mutex_);
+    std::lock_guard its_lock(socket_mutex_);
     if (socket_->is_open()) {
         socket_->async_receive(
             boost::asio::buffer(recv_buffer_),
@@ -232,11 +232,11 @@ void local_uds_client_endpoint_impl::send_queued(std::pair<message_buffer_ptr_t,
     bufs.push_back(boost::asio::buffer(its_end_tag));
 
     {
-        std::lock_guard<std::mutex> its_lock(socket_mutex_);
+        std::scoped_lock its_lock(socket_mutex_);
 
         auto its_me {std::dynamic_pointer_cast<local_uds_client_endpoint_impl>(shared_from_this())};
         auto buffer_ptr = _entry.first; // Capture shared_ptr to ensure it stays alive
-        
+
         if(socket_->is_open()) {
             boost::asio::async_write(
                     *socket_, bufs,
@@ -247,7 +247,7 @@ void local_uds_client_endpoint_impl::send_queued(std::pair<message_buffer_ptr_t,
             VSOMEIP_WARNING << "lucei::" << __func__ << ": try to send while socket was not open | endpoint > " << this;
             was_not_connected_ = true;
             is_sending_ = false;
-        } 
+        }
     }
 }
 
@@ -287,7 +287,7 @@ void local_uds_client_endpoint_impl::receive_cbk(
         }
         error_handler_t handler;
         {
-            std::lock_guard<std::mutex> its_lock(error_handler_mutex_);
+            std::scoped_lock its_lock(error_handler_mutex_);
             handler = error_handler_;
         }
         if (handler)
@@ -394,7 +394,7 @@ void local_uds_client_endpoint_impl::max_allowed_reconnects_reached() {
             << get_remote_information();
     error_handler_t handler;
     {
-        std::lock_guard<std::mutex> its_lock(error_handler_mutex_);
+        std::scoped_lock its_lock(error_handler_mutex_);
         handler = error_handler_;
     }
     if (handler)