Use reference to prevent copying

Since the variables are marked as const - we are not going to change
them, we may also take them by ref. Which means we just want to see the
variables.

This improves the performance and also helps to generate minimal code.

implementation/compat/runtime/src/application_impl.cpp

@@ -638,7 +638,7 @@ application_impl::is_selective_event(
     if (its_service != eventgroups_.end()) {
         const auto its_instance = its_service->second.find(_instance);
         if (its_instance != its_service->second.end()) {
-            for (const auto eg : _eventgroups) {
+            for (const auto& eg : _eventgroups) {
                 const auto its_egrp = its_instance->second.find(eg);
                 if (its_egrp != its_instance->second.end()) {
                     is_selective = true;

implementation/configuration/src/configuration_impl.cpp

@@ -3972,7 +3972,7 @@ configuration_impl::load_overlay(const std::string &_name) {
         its_input.insert(its_overlay);
         read_data(its_input, its_elements, its_failed, false);
 
-        for (const auto f : its_failed)
+        for (const auto& f : its_failed)
             VSOMEIP_ERROR << "Reading configuration data from " << f << " failed!";
 
         is_overlay_ = true;

implementation/endpoints/src/endpoint_manager_base.cpp

@@ -158,7 +158,7 @@ endpoint_manager_base::log_client_states() const {
 
     {
         std::lock_guard<std::mutex> its_lock(local_endpoint_mutex_);
-        for (const auto e : local_endpoints_) {
+        for (const auto& e : local_endpoints_) {
             size_t its_queue_size = e.second->get_queue_size();
             if (its_queue_size > VSOMEIP_DEFAULT_QUEUE_WARN_SIZE) {
                 its_client_queue_sizes.push_back(

implementation/endpoints/src/endpoint_manager_impl.cpp

@@ -983,9 +983,9 @@ endpoint_manager_impl::log_client_states() const {
         its_client_endpoints = client_endpoints_by_ip_;
     }
 
-    for (const auto its_address : its_client_endpoints) {
-        for (const auto its_port : its_address.second) {
-            for (const auto its_reliability : its_port.second) {
+    for (const auto& its_address : its_client_endpoints) {
+        for (const auto& its_port : its_address.second) {
+            for (const auto& its_reliability : its_port.second) {
                 size_t its_queue_size = its_reliability.second->get_queue_size();
                 if (its_queue_size > VSOMEIP_DEFAULT_QUEUE_WARN_SIZE)
                     its_client_queue_sizes.push_back(
@@ -1040,8 +1040,8 @@ endpoint_manager_impl::log_server_states() const {
         its_server_endpoints = server_endpoints_;
     }
 
-    for (const auto its_port : its_server_endpoints) {
-        for (const auto its_reliability : its_port.second) {
+    for (const auto& its_port : its_server_endpoints) {
+        for (const auto& its_reliability : its_port.second) {
             size_t its_queue_size = its_reliability.second->get_queue_size();
             if (its_queue_size > VSOMEIP_DEFAULT_QUEUE_WARN_SIZE)
                 its_client_queue_sizes.push_back(

implementation/endpoints/src/server_endpoint_impl.cpp

@@ -757,7 +757,7 @@ size_t server_endpoint_impl<Protocol>::get_queue_size() const {
 
     {
         std::lock_guard<std::mutex> its_lock(mutex_);
-        for (const auto q : queues_) {
+        for (const auto& q : queues_) {
             its_queue_size += q.second.second.size();
         }
     }

implementation/routing/src/eventgroupinfo.cpp

@@ -223,7 +223,7 @@ eventgroupinfo::update_remote_subscription(
             _id = its_item.second->get_id();
 
             // Copy acknowledgment states from existing subscription
-            for (const auto its_client : _subscription->get_clients()) {
+            for (const auto& its_client : _subscription->get_clients()) {
                 _subscription->set_client_state(its_client,
                         its_item.second->get_client_state(its_client));
             }
@@ -390,10 +390,10 @@ eventgroupinfo::send_initial_events(
     }
 
     // Send events
-    for (const auto its_event : its_reliable_events)
+    for (const auto& its_event : its_reliable_events)
         its_event->notify_one(VSOMEIP_ROUTING_CLIENT, _reliable);
 
-    for (const auto its_event : its_unreliable_events)
+    for (const auto& its_event : its_unreliable_events)
         its_event->notify_one(VSOMEIP_ROUTING_CLIENT, _unreliable);
 }
 

implementation/routing/src/remote_subscription.cpp

@@ -135,7 +135,7 @@ std::set<client_t>
 remote_subscription::get_clients() const {
     std::lock_guard<std::mutex> its_lock(mutex_);
     std::set<client_t> its_clients;
-    for (const auto its_item : clients_)
+    for (const auto& its_item : clients_)
         its_clients.insert(its_item.first);
     return its_clients;
 }

implementation/routing/src/routing_manager_impl.cpp

@@ -278,7 +278,7 @@ void routing_manager_impl::stop() {
         discovery_->stop();
     stub_->stop();
 
-    for (const auto client : ep_mgr_->get_connected_clients()) {
+    for (const auto& client : ep_mgr_->get_connected_clients()) {
         if (client != VSOMEIP_ROUTING_CLIENT) {
             remove_local(client, true);
         }
@@ -1163,7 +1163,7 @@ void routing_manager_impl::notify_one(service_t _service, instance_t _instance,
         if (its_event) {
             std::set<std::shared_ptr<endpoint_definition> > its_targets;
             const auto its_reliability = its_event->get_reliability();
-            for (const auto g : its_event->get_eventgroups()) {
+            for (const auto& g : its_event->get_eventgroups()) {
                 const auto its_eventgroup = find_eventgroup(_service, _instance, g);
                 if (its_eventgroup) {
                     const auto its_subscriptions = its_eventgroup->get_remote_subscriptions();
@@ -1887,7 +1887,7 @@ bool routing_manager_impl::deliver_notification(
                 // no subscribers for this specific event / check subscriptions
                 // to other events of the event's eventgroups
                 bool cache_event = false;
-                for (const auto eg : its_event->get_eventgroups()) {
+                for (const auto& eg : its_event->get_eventgroups()) {
                     std::shared_ptr<eventgroupinfo> egi = find_eventgroup(_service, _instance, eg);
                     if (egi) {
                         for (const auto &e : egi->get_events()) {
@@ -1927,7 +1927,7 @@ bool routing_manager_impl::deliver_notification(
                 utility::get_payload_size(_data, _length));
 
         if (its_event->get_type() != event_type_e::ET_SELECTIVE_EVENT) {
-            for (const auto its_local_client : its_event->get_subscribers()) {
+            for (const auto& its_local_client : its_event->get_subscribers()) {
                 if (its_local_client == host_->get_client()) {
                     deliver_message(_data, _length, _instance, _reliable,
                             _bound_client, _credentials, _status_check, _is_from_remote);
@@ -2412,7 +2412,7 @@ void routing_manager_impl::del_routing_info(service_t _service, instance_t _inst
                     // longer valid.
                     for (auto &its_event : its_eventgroup.second->get_events()) {
                         const auto its_subscribers = its_event->get_subscribers();
-                        for (const auto its_subscriber : its_subscribers) {
+                        for (const auto& its_subscriber : its_subscribers) {
                             if (its_subscriber != get_client()) {
                                 its_event->remove_subscriber(
                                         its_eventgroup.first, its_subscriber);
@@ -2436,14 +2436,14 @@ void routing_manager_impl::del_routing_info(service_t _service, instance_t _inst
         std::set<std::tuple<
             service_t, instance_t, eventgroup_t, client_t> > its_invalid;
 
-        for (const auto its_state : remote_subscription_state_) {
+        for (const auto& its_state : remote_subscription_state_) {
             if (std::get<0>(its_state.first) == _service
                     && std::get<1>(its_state.first) == _instance) {
                 its_invalid.insert(its_state.first);
             }
         }
 
-        for (const auto its_key : its_invalid)
+        for (const auto& its_key : its_invalid)
             remote_subscription_state_.erase(its_key);
     }
 
@@ -3770,7 +3770,7 @@ void routing_manager_impl::clear_targets_and_pending_sub_from_eventgroups(
                     // longer valid.
                     for (auto &its_event : its_eventgroup.second->get_events()) {
                         const auto its_subscribers = its_event->get_subscribers();
-                        for (const auto its_subscriber : its_subscribers) {
+                        for (const auto& its_subscriber : its_subscribers) {
                             if (its_subscriber != get_client()) {
                                 its_event->remove_subscriber(
                                         its_eventgroup.first, its_subscriber);
@@ -4112,7 +4112,7 @@ void routing_manager_impl::send_subscription(
         const remote_subscription_id_t _id) {
     if (host_->get_client() == _offering_client) {
         auto self = shared_from_this();
-        for (const auto its_client : _clients) {
+        for (const auto& its_client : _clients) {
             host_->on_subscription(_service, _instance, _eventgroup, its_client, own_uid_, own_gid_, true,
                 [this, self, _service, _instance, _eventgroup, its_client, _id]
                         (const bool _is_accepted) {
@@ -4138,7 +4138,7 @@ void routing_manager_impl::send_subscription(
             });
         }
     } else { // service hosted by local client
-        for (const auto its_client : _clients) {
+        for (const auto& its_client : _clients) {
             if (!stub_->send_subscribe(find_local(_offering_client), its_client,
                     _service, _instance, _eventgroup, _major, ANY_EVENT, _id)) {
                 try {
@@ -4266,7 +4266,7 @@ routing_manager_impl::send_unsubscription(client_t _offering_client,
 
     if (host_->get_client() == _offering_client) {
         auto self = shared_from_this();
-        for (const auto its_client : _removed) {
+        for (const auto& its_client : _removed) {
             host_->on_subscription(_service, _instance,
                     _eventgroup, its_client, own_uid_, own_gid_, false,
                 [this, self, _service, _instance, _eventgroup,
@@ -4286,7 +4286,7 @@ routing_manager_impl::send_unsubscription(client_t _offering_client,
             );
         }
     } else {
-        for (const auto its_client : _removed) {
+        for (const auto& its_client : _removed) {
             if (!stub_->send_unsubscribe(find_local(_offering_client), its_client,
                     _service, _instance, _eventgroup, ANY_EVENT, _id)) {
                 try {
@@ -4347,7 +4347,7 @@ bool routing_manager_impl::insert_event_statistics(service_t _service, instance_
             // check list for entry with least counter value
             uint32_t its_min_count(0xFFFFFFFF);
             auto its_tuple_to_discard = std::make_tuple(0xFFFF, 0xFFFF, 0xFFFF);
-            for (const auto it : message_statistics_) {
+            for (const auto& it : message_statistics_) {
                 if (it.second.counter_ < its_min_count) {
                     its_min_count = it.second.counter_;
                     its_tuple_to_discard = it.first;
@@ -4389,7 +4389,7 @@ void routing_manager_impl::statistics_log_timer_cbk(boost::system::error_code co
         std::stringstream its_log;
         {
             std::lock_guard<std::mutex> its_lock(message_statistics_mutex_);
-            for (const auto s : message_statistics_) {
+            for (const auto& s : message_statistics_) {
                 if (s.second.counter_ / (its_interval / 1000) >= its_min_freq) {
                     uint16_t its_subscribed(0);
                     std::shared_ptr<event> its_event = find_event(std::get<0>(s.first), std::get<1>(s.first), std::get<2>(s.first));

implementation/routing/src/routing_manager_proxy.cpp

@@ -125,7 +125,7 @@ void routing_manager_proxy::stop() {
         sender_ = nullptr;
     }
 
-    for (const auto client : ep_mgr_->get_connected_clients()) {
+    for (const auto& client : ep_mgr_->get_connected_clients()) {
         if (client != VSOMEIP_ROUTING_CLIENT) {
             remove_local(client, true);
         }
@@ -1733,7 +1733,7 @@ void routing_manager_proxy::on_routing_info(const byte_t *_data,
                 for (const client_t client : known_clients_) {
                     auto its_client = pending_incoming_subscripitons_.find(client);
                     if (its_client != pending_incoming_subscripitons_.end()) {
-                        for (const auto subscription : its_client->second) {
+                        for (const auto& subscription : its_client->second) {
                             subscription_actions.push_front(
                                 { subscription.service_, subscription.instance_,
                                         subscription.eventgroup_, client,
@@ -1850,7 +1850,7 @@ void routing_manager_proxy::reconnect(const std::unordered_set<client_t> &_clien
 
 
     // Remove all local connections/endpoints
-    for (const auto its_client : _clients) {
+    for (const auto& its_client : _clients) {
         if (its_client != VSOMEIP_ROUTING_CLIENT) {
             remove_local(its_client, true);
         }

implementation/routing/src/routing_manager_stub.cpp

@@ -2257,7 +2257,7 @@ routing_manager_stub::send_requester_policies(const std::unordered_set<client_t>
     pending_security_update_id_t its_policy_id;
 
     // serialize the policies and send them...
-    for (const auto p : _policies) {
+    for (const auto& p : _policies) {
         std::vector<byte_t> its_policy_data;
         if (p->serialize(its_policy_data)) {
             std::vector<byte_t> its_message;
@@ -2279,7 +2279,7 @@ routing_manager_stub::send_requester_policies(const std::unordered_set<client_t>
 
             its_message.insert(its_message.end(), its_policy_data.begin(), its_policy_data.end());
 
-            for (const auto c : _clients) {
+            for (const auto& c : _clients) {
                 std::shared_ptr<endpoint> its_endpoint = host_->find_local(c);
                 if (its_endpoint)
                     its_endpoint->send(&its_message[0], static_cast<uint32_t>(its_message.size()));

implementation/runtime/src/application_impl.cpp

@@ -2157,7 +2157,7 @@ bool application_impl::check_for_active_subscription(service_t _service,
                         std::shared_ptr<event> its_event = routing_->find_event(
                                 _service, _instance, _event);
                         if (its_event) {
-                            for (const auto eg : its_event->get_eventgroups()) {
+                            for (const auto& eg : its_event->get_eventgroups()) {
                                 auto found_eventgroup = found_any_event->second.find(eg);
                                 if (found_eventgroup != found_any_event->second.end()) {
                                     // set the flag for initial event received to true

implementation/security/src/policy.cpp

@@ -175,7 +175,7 @@ policy::deserialize_ids(const byte_t * &_data, uint32_t &_size,
         if (its_result == false)
             return (false);
 
-        for (const auto i : its_instances)
+        for (const auto& i : its_instances)
             its_ids += std::make_pair(i, its_methods);
 
         its_array_length -= (its_current_size - _size);
@@ -305,7 +305,7 @@ policy::serialize(std::vector<byte_t> &_data) const {
     uint32_t its_requests_size(0);
     serialize_u32(its_requests_size, _data);
 
-    for (const auto its_request : requests_) {
+    for (const auto& its_request : requests_) {
         for (auto its_service = its_request.first.lower();
                 its_service <= its_request.first.upper();
                 its_service++) {
@@ -316,7 +316,7 @@ policy::serialize(std::vector<byte_t> &_data) const {
             uint32_t its_instances_size(0);
             serialize_u32(its_instances_size, _data);
 
-            for (const auto i : its_request.second) {
+            for (const auto& i : its_request.second) {
                 boost::icl::interval_set<instance_t> its_instances;
                 its_instances.insert(i.first);
                 serialize_interval_set(its_instances, _data);
@@ -378,7 +378,7 @@ policy::serialize_interval_set(
     uint32_t its_interval_set_size(0);
     serialize_u32(its_interval_set_size, _data);
 
-    for (const auto i : _intervals)
+    for (const auto& i : _intervals)
         serialize_interval(i, _data);
 
     its_interval_set_size = static_cast<uint32_t>(_data.size()