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

@@ -16,3 +16,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

@@ -3051,7 +3051,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

@@ -976,7 +976,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(
@@ -1346,7 +1346,7 @@ endpoint_manager_impl::add_multicast_option(const multicast_option_t &_option) {
 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_) {
         if (options_queue_.size() > 0
         && static_cast<routing_manager_impl*>(rm_)->is_external_routing_ready()) {

implementation/endpoints/src/local_tcp_client_endpoint_impl.cpp

@@ -115,7 +115,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

@@ -235,7 +235,7 @@ void local_tcp_server_endpoint_impl::accept_cbk(
         boost::system::error_code its_error;
         endpoint_type remote;
         {
-            std::unique_lock<std::mutex> its_socket_lock(_connection->get_socket_lock());
+            std::unique_lock its_socket_lock{_connection->get_socket_lock()};
             socket_type &new_connection_socket = _connection->get_socket();
 
             // Nagle algorithm off
@@ -867,7 +867,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

@@ -56,7 +56,7 @@ void local_uds_client_endpoint_impl::restart(bool _force) {
         queue_size_ = 0;
     }
     {
-        std::lock_guard<std::mutex> its_lock(socket_mutex_);
+        std::lock_guard its_lock(socket_mutex_);
         shutdown_and_close_socket_unlocked(true);
     }
     state_ = cei_state_e::CONNECTING;
@@ -77,19 +77,19 @@ void local_uds_client_endpoint_impl::start() {
 
 void local_uds_client_endpoint_impl::stop() {
     {
-        std::lock_guard<std::recursive_mutex> its_lock(mutex_);
+        std::lock_guard its_lock(mutex_);
         sending_blocked_ = true;
     }
     {
-        std::lock_guard<std::mutex> its_lock(connect_timer_mutex_);
+        std::lock_guard its_lock(connect_timer_mutex_);
         boost::system::error_code ec;
         connect_timer_.cancel(ec);
     }
     connect_timeout_ = VSOMEIP_DEFAULT_CONNECT_TIMEOUT;
 
     bool is_open(false);
     {
-        std::lock_guard<std::mutex> its_lock(socket_mutex_);
+        std::lock_guard 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,7 +232,7 @@ 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::lock_guard its_lock(socket_mutex_);
         if(socket_->is_open()) {
             boost::asio::async_write(
                 *socket_, bufs,
@@ -284,7 +284,7 @@ void local_uds_client_endpoint_impl::receive_cbk(
         }
         error_handler_t handler;
         {
-            std::lock_guard<std::mutex> its_lock(error_handler_mutex_);
+            std::lock_guard its_lock(error_handler_mutex_);
             handler = error_handler_;
         }
         if (handler)
@@ -391,7 +391,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::lock_guard its_lock(error_handler_mutex_);
         handler = error_handler_;
     }
     if (handler)