Code Quality: Address shadowing (#840)

Summary
Code Quality: Address shadowing
Details

Addresses most shadowing variables
Fixes some old style C-casts
Fixed static_cast and scoped_locks

Co-authored-by: Duarte Fonseca <[email protected]>

Author: kheaactua

implementation/configuration/src/configuration_impl.cpp

@@ -2283,24 +2283,23 @@ void configuration_impl::load_eventgroup(
                 }
                 its_converter >> its_eventgroup->id_;
             } else if (its_key == "is_multicast") {
-                std::string its_value(j->second.data());
-                if (its_value == "true") {
+                std::string its_value_inner(j->second.data());
+                if (its_value_inner == "true") {
                     its_eventgroup->multicast_address_ = _service->multicast_address_;
                     its_eventgroup->multicast_port_ = _service->multicast_port_;
                 }
             } else if (its_key == "multicast") {
                 try {
-                    std::string its_value = j->second.get_child("address").data();
-                    its_eventgroup->multicast_address_ = its_value;
-                    its_value = j->second.get_child("port").data();
-                    its_converter << its_value;
+                    std::string its_value_inner = j->second.get_child("address").data();
+                    its_eventgroup->multicast_address_ = its_value_inner;
+                    its_value_inner = j->second.get_child("port").data();
+                    its_converter << its_value_inner;
                     its_converter >> its_eventgroup->multicast_port_;
                 } catch (...) {
                     // intentionally left empty
                 }
             } else if (its_key == "threshold") {
                 int its_threshold(0);
-                std::stringstream its_converter;
                 its_converter << std::dec << its_value;
                 its_converter >> std::dec >> its_threshold;
                 its_eventgroup->threshold_ =
@@ -2309,13 +2308,12 @@ void configuration_impl::load_eventgroup(
                                 static_cast<uint8_t>(its_threshold);
             } else if (its_key == "events") {
                 for (auto k = j->second.begin(); k != j->second.end(); ++k) {
-                    std::stringstream its_converter;
-                    std::string its_value(k->second.data());
+                    std::string its_value_inner(k->second.data());
                     event_t its_event_id(0);
-                    if (its_value.size() > 1 && its_value[0] == '0' && its_value[1] == 'x') {
-                        its_converter << std::hex << its_value;
+                    if (its_value_inner.size() > 1 && its_value_inner[0] == '0' && its_value_inner[1] == 'x') {
+                        its_converter << std::hex << its_value_inner;
                     } else {
-                        its_converter << std::dec << its_value;
+                        its_converter << std::dec << its_value_inner;
                     }
                     its_converter >> its_event_id;
                     if (0 < its_event_id) {
@@ -3565,7 +3563,6 @@ bool configuration_impl::find_specific_port(uint16_t &_port, service_t _service,
         std::map<bool, std::set<uint16_t> > &_used_client_ports) const {
     bool is_configured(false);
     bool check_all(false);
-    std::list<std::shared_ptr<client>>::const_iterator it;
     auto its_client = find_client(_service, _instance);
 
     // Check for service, instance specific port configuration
@@ -3594,7 +3591,7 @@ bool configuration_impl::find_specific_port(uint16_t &_port, service_t _service,
                         << " service: " << std::hex << _service
                         << " instance: " << _instance
                         << " reliable: " << std::dec << _reliable
-                        << " return specific port: " << (uint32_t)_port;
+                        << " return specific port: " << static_cast<uint32_t>(_port);
                 return true;
             }
             ++it;
@@ -3611,7 +3608,7 @@ bool configuration_impl::find_specific_port(uint16_t &_port, service_t _service,
                             << " service: " << std::hex << _service
                             << " instance: " << _instance
                             << " reliable: " << std::dec << _reliable
-                            << " return specific port: " << (uint32_t)_port;
+                            << " return specific port: " << static_cast<uint32_t>(_port);
                     return true;
                 }
             }
@@ -4395,25 +4392,25 @@ void configuration_impl::load_acceptance_data(const boost::property_tree::ptree&
                         port_type_e its_type(port_type_e::PT_OPTIONAL);
 
                         for (const auto& range : p.second) {
-                            const std::string its_key(range.first);
-                            const std::string its_value(range.second.data());
-                            if (its_key == "first" || its_key == "last" || its_key == "port") {
-                                its_converter << std::dec << its_value;
+                            const std::string its_key_inner(range.first);
+                            const std::string its_value_inner(range.second.data());
+                            if (its_key_inner == "first" || its_key_inner == "last" || its_key_inner == "port") {
+                                its_converter << std::dec << its_value_inner;
                                 std::uint16_t its_port_value(0);
                                 its_converter >> its_port_value;
                                 its_converter.str("");
                                 its_converter.clear();
-                                if (its_key == "first") {
+                                if (its_key_inner == "first") {
                                     its_first = its_port_value;
-                                } else if (its_key == "last") {
+                                } else if (its_key_inner == "last") {
                                     its_last = its_port_value;
-                                } else if (its_key == "port") {
+                                } else if (its_key_inner == "port") {
                                     its_first = its_last = its_port_value;
                                 }
-                            } else if (its_key == "type") {
-                                if (its_value == "secure") {
+                            } else if (its_key_inner == "type") {
+                                if (its_value_inner == "secure") {
                                     its_type = port_type_e::PT_SECURE;
-                                } else if (its_value == "optional") {
+                                } else if (its_value_inner == "optional") {
                                     its_type = port_type_e::PT_OPTIONAL;
                                 } else {
                                     its_type = port_type_e::PT_UNKNOWN;
@@ -4604,17 +4601,17 @@ void configuration_impl::load_someip_tp_for_service(
             const std::string its_value(method.second.data());
             if (its_value.empty()) {
                 for (const auto &its_data : method.second) {
-                    const std::string its_value(its_data.second.data());
-                    if (!its_value.empty()) {
+                    const std::string its_value_inner(its_data.second.data());
+                    if (!its_value_inner.empty()) {
                         if (its_data.first == "method") {
-                            if (its_value.size() > 1 && its_value[0] == '0' && its_value[1] == 'x') {
-                                its_converter << std::hex << its_value;
+                            if (its_value_inner.size() > 1 && its_value_inner[0] == '0' && its_value_inner[1] == 'x') {
+                                its_converter << std::hex << its_value_inner;
                             } else {
-                                its_converter << std::dec << its_value;
+                                its_converter << std::dec << its_value_inner;
                             }
                             its_converter >> its_method;
                         } else if (its_data.first == "max-segment-length") {
-                            its_converter << std::dec << its_value;
+                            its_converter << std::dec << its_value_inner;
                             its_converter >> its_max_segment_length;
 
                             // Segment length must be multiple of 16
@@ -4628,7 +4625,7 @@ void configuration_impl::load_someip_tp_for_service(
                                 its_max_segment_length = std::uint16_t(its_max_segment_length - its_rest);
                             }
                         } else if (its_data.first == "separation-time") {
-                            its_converter << std::dec << its_value;
+                            its_converter << std::dec << its_value_inner;
                             its_converter >> its_separation_time;
                             its_separation_time *= std::uint32_t(1000);
                         }
@@ -4998,11 +4995,11 @@ void configuration_impl::set_sd_acceptance_rule(
                 sd_acceptance_rules_active_.insert(_address);
             }
 
-            const auto found_reliability = found_address->second.second.find(_reliable);
+            const auto found_reliability_inner = found_address->second.second.find(_reliable);
             VSOMEIP_INFO << "ipsec:acceptance:" << _address << "[" << _path << "]"
                     << ":" << (_reliable ? "tcp" : "udp") << ": using default ranges "
-                    << found_reliability->second.first << " "
-                    << found_reliability->second.second;
+                    << found_reliability_inner->second.first << " "
+                    << found_reliability_inner->second.second;
         }
     } else if (_enable) {
         boost::icl::interval_set<std::uint16_t> its_optional_default;
@@ -5034,14 +5031,14 @@ void configuration_impl::set_sd_acceptance_rule(
             sd_acceptance_rules_active_.insert(_address);
         }
 
-        const auto found_address = sd_acceptance_rules_.find(_address);
-        if (found_address != sd_acceptance_rules_.end()) {
-            const auto found_reliability = found_address->second.second.find(_reliable);
-            if (found_reliability != found_address->second.second.end()) {
-                VSOMEIP_INFO << "ipsec:acceptance:" << _address << "[" << _path << "]"
+        const auto found_address_inner = sd_acceptance_rules_.find(_address);
+        if (found_address_inner != sd_acceptance_rules_.end()) {
+            const auto found_reliability_inner = found_address_inner->second.second.find(_reliable);
+            if (found_reliability_inner != found_address_inner->second.second.end()) {
+                VSOMEIP_INFO << "ipsec:acceptance:" << _address
                         << ":" << (_reliable ? "tcp" : "udp") << ": using default ranges "
-                        << found_reliability->second.first << " "
-                        << found_reliability->second.second;
+                        << found_reliability_inner->second.first << " "
+                        << found_reliability_inner->second.second;
             }
         }
     }

implementation/endpoints/include/netlink_connector.hpp

@@ -111,8 +111,8 @@ class nl_protocol {
     nl_protocol() {
         proto = 0;
     }
-    nl_protocol(int proto) {
-        this->proto = proto;
+    nl_protocol(int _proto) {
+        proto = _proto;
     }
     /// Obtain an identifier for the type of the protocol.
     int type() const

implementation/endpoints/src/endpoint_manager_impl.cpp

@@ -1109,9 +1109,9 @@ endpoint_manager_impl::find_remote_client(
                                 service_instances_[_service][its_endpoint.get()] = _instance;
 
                                 // add endpoint to serviceinfo object
-                                auto found_service_info = rm_->find_service(_service,_instance);
-                                if (found_service_info) {
-                                    found_service_info->set_endpoint(its_endpoint, _reliable);
+                                auto found_service_info_inner = rm_->find_service(_service,_instance);
+                                if (found_service_info_inner) {
+                                    found_service_info_inner->set_endpoint(its_endpoint, _reliable);
                                 }
                             }
                         }

implementation/endpoints/src/local_tcp_server_endpoint_impl.cpp

@@ -57,7 +57,7 @@ bool local_tcp_server_endpoint_impl::is_local() const {
 
 void local_tcp_server_endpoint_impl::init(const endpoint_type& _local,
                                           boost::system::error_code& _error) {
-    std::lock_guard<std::mutex> its_lock(acceptor_mutex_);
+    std::scoped_lock its_lock{acceptor_mutex_};
     init_unlocked(_local, _error);
 }
 
@@ -99,7 +99,7 @@ void local_tcp_server_endpoint_impl::deinit() {
 
 void local_tcp_server_endpoint_impl::start() {
 
-    std::lock_guard<std::mutex> its_lock(acceptor_mutex_);
+    std::scoped_lock its_lock{acceptor_mutex_};
     if (!acceptor_->is_open()) {
         boost::system::error_code its_error;
         init_unlocked(local_, its_error);
@@ -113,7 +113,7 @@ void local_tcp_server_endpoint_impl::start() {
                         io_);
 
         {
-            std::unique_lock<std::mutex> its_lock(new_connection->get_socket_lock());
+            std::unique_lock its_lock_inner{new_connection->get_socket_lock()};
             acceptor_->async_accept(
                     new_connection->get_socket(),
                     std::bind(&local_tcp_server_endpoint_impl::accept_cbk,
@@ -128,14 +128,14 @@ void local_tcp_server_endpoint_impl::stop() {
 
     server_endpoint_impl::stop();
     {
-        std::lock_guard<std::mutex> its_lock(acceptor_mutex_);
+        std::scoped_lock its_lock{acceptor_mutex_};
         if (acceptor_->is_open()) {
             boost::system::error_code its_error;
             acceptor_->close(its_error);
         }
     }
     {
-        std::lock_guard<std::mutex> its_lock(connections_mutex_);
+        std::scoped_lock its_lock{connections_mutex_};
         for (const auto &c : connections_) {
             c.second->stop();
         }
@@ -151,7 +151,7 @@ bool local_tcp_server_endpoint_impl::send(const uint8_t *_data, uint32_t _size)
         msg << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(_data[i]) << " ";
     VSOMEIP_INFO << msg.str();
 #endif
-    std::lock_guard<std::mutex> its_lock(mutex_);
+    std::scoped_lock its_lock{mutex_};
     if (endpoint_impl::sending_blocked_) {
         return false;
     }
@@ -161,7 +161,7 @@ bool local_tcp_server_endpoint_impl::send(const uint8_t *_data, uint32_t _size)
 
     connection::ptr its_connection;
     {
-        std::lock_guard<std::mutex> its_lock(connections_mutex_);
+        std::scoped_lock its_lock_inner{connections_mutex_};
         const auto its_iterator = connections_.find(its_client);
         if (its_iterator == connections_.end()) {
             return false;
@@ -221,7 +221,7 @@ bool local_tcp_server_endpoint_impl::add_connection(const client_t &_client,
         const std::shared_ptr<connection> &_connection) {
 
     bool ret = false;
-    std::lock_guard<std::mutex> its_lock(connections_mutex_);
+    std::scoped_lock its_lock{connections_mutex_};
     auto find_connection = connections_.find(_client);
     if (find_connection == connections_.end()) {
         connections_[_client] = _connection;
@@ -236,7 +236,7 @@ bool local_tcp_server_endpoint_impl::add_connection(const client_t &_client,
 void local_tcp_server_endpoint_impl::remove_connection(
         const client_t &_client) {
 
-    std::lock_guard<std::mutex> its_lock(connections_mutex_);
+    std::scoped_lock its_lock{connections_mutex_};
     if (!connections_.erase(_client)) {
         VSOMEIP_WARNING << "Client " << std::hex << _client << " has no registered connection to "
                         << " remove, endpoint > " << this;
@@ -321,8 +321,8 @@ void local_tcp_server_endpoint_impl::accept_cbk(
         auto its_ep = std::dynamic_pointer_cast<local_tcp_server_endpoint_impl>(
                 shared_from_this());
         its_timer->async_wait([its_timer, its_ep]
-                               (const boost::system::error_code& _error) {
-            if (!_error) {
+                               (const boost::system::error_code& _error_inner) {
+            if (!_error_inner) {
                 its_ep->start();
             }
         });
@@ -378,7 +378,7 @@ local_tcp_server_endpoint_impl::connection::get_socket_lock() {
 }
 
 void local_tcp_server_endpoint_impl::connection::start() {
-    std::lock_guard<std::mutex> its_lock(socket_mutex_);
+    std::scoped_lock its_lock{socket_mutex_};
     if (socket_->is_open()) {
         const std::size_t its_capacity(recv_buffer_.capacity());
         if (recv_buffer_size_ > its_capacity) {
@@ -431,7 +431,7 @@ void local_tcp_server_endpoint_impl::connection::start() {
 }
 
 void local_tcp_server_endpoint_impl::connection::stop() {
-    std::lock_guard<std::mutex> its_lock(socket_mutex_);
+    std::scoped_lock its_lock{socket_mutex_};
     is_stopped_ = true;
     if (socket_->is_open()) {
 #if defined(__linux__) || defined(ANDROID) || defined(__QNX__)
@@ -474,7 +474,7 @@ void local_tcp_server_endpoint_impl::connection::send_queued(
     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_};
         socket_->async_write(bufs,
                              std::bind(&local_tcp_server_endpoint_impl::connection::send_cbk,
                                        shared_from_this(), _buffer, std::placeholders::_1,
@@ -617,7 +617,7 @@ void local_tcp_server_endpoint_impl::connection::receive_cbk(
                 }
                 if (its_command_size && max_message_size_ != MESSAGE_SIZE_UNLIMITED
                         && its_command_size > max_message_size_) {
-                    std::lock_guard<std::mutex> its_lock(socket_mutex_);
+                    std::scoped_lock its_lock{socket_mutex_};
                     VSOMEIP_ERROR << "Received a local message which exceeds "
                           << "maximum message size (" << std::dec << its_command_size
                           << ") aborting! local: " << get_path_local() << " remote: "
@@ -903,7 +903,7 @@ local_tcp_server_endpoint_impl::connection::get_recv_buffer_capacity() const {
 
 void
 local_tcp_server_endpoint_impl::connection::shutdown_and_close() {
-    std::lock_guard<std::mutex> its_lock(socket_mutex_);
+    std::scoped_lock its_lock{socket_mutex_};
     shutdown_and_close_unlocked();
 }
 
@@ -915,10 +915,10 @@ local_tcp_server_endpoint_impl::connection::shutdown_and_close_unlocked() {
 }
 
 void local_tcp_server_endpoint_impl::print_status() {
-    std::lock_guard<std::mutex> its_lock(mutex_);
+    std::scoped_lock its_lock{mutex_};
     connections_t its_connections;
     {
-        std::lock_guard<std::mutex> its_lock(connections_mutex_);
+        std::scoped_lock its_lock_inner{connections_mutex_};
         its_connections = connections_;
     }
     std::string its_local_path("TCP");