Method remove_local

implementation/routing/src/routing_manager_client.cpp:2340–2395

}

void routing_manager_client::remove_local(bool _due_to_error, client_t _client, std::set<protocol::service>& _requested_services) {

    vsomeip_sec_client_t its_sec_client;
    configuration_->get_policy_manager()->get_client_to_sec_client_mapping(_client, its_sec_client);
    configuration_->get_policy_manager()->remove_client_to_sec_client_mapping(_client);
    auto ep = ep_mgr_->find_local_server_endpoint(_client);
    std::string const env = ep ? ep->get_env() : "";
    {
        std::scoped_lock its_lock(provider_mutex_);
        auto const subscribed_eventgroups = get_subscriptions(_client, its_lock);
        for (auto its_subscription : subscribed_eventgroups) {
            auto [its_service, its_instance, its_eventgroup] = its_subscription;
            // because we are in the remove local function within which the connection token is bumped,
            // any inflight subscription for this client is going to be dropped, therefore adjust the book-keeping
            // immediately.
            unsubscribe_base(_client, its_service, its_instance, its_eventgroup, ANY_EVENT, its_lock);
            VSOMEIP_INFO << "UNSUBSCRIBE(" << hex4(_client) << "): [" << hex4(its_service) << "." << hex4(its_instance) << "."
                         << hex4(its_eventgroup) << "." << hex4(ANY_EVENT) << "]";
            host_->on_subscription(its_service, its_instance, its_eventgroup, _client, &its_sec_client, env, false, [](bool) {
                // no need to execute anything, subscribers are updated already
            });
        }
        // remove the provider endpoint under the provider_mutex_ to ensure that no subscription callback (dispatcher thread)
        // can mess up the book-keeping when checking the endpoint token
        ep_mgr_->remove_provider_endpoint(_client, _due_to_error);
    }
    ep_mgr_->remove_consumer_endpoint(_client, _due_to_error);
    {
        std::scoped_lock its_lock(consumer_mutex_);
        address_table_.erase(_client);
        auto removed = available_services_.remove_all_for_client(_client);
        for (auto const& [its_service, its_instance, its_major, its_minor, its_client] : removed) {
            // save the removed available services to re-request them from the router
            _requested_services.emplace(its_service, its_instance, its_major, its_minor);
            on_stop_offer_service(its_service, its_instance, its_major, its_minor, its_lock);
        }

        // remove disconnected client from offer service history
        std::set<std::tuple<service_t, instance_t, client_t>> its_clients;
        for (const auto& [si, clients] : available_services_history_) {
            for (const auto& c : clients) {
                if (c == _client) {
                    its_clients.insert(std::make_tuple(si.service(), si.instance(), c));
                }
            }
        }

        for (auto& sic : its_clients) {
            const service_instance_t si{std::get<0>(sic), std::get<1>(sic)};
            available_services_history_[si].erase(std::get<2>(sic));
            if (available_services_history_[si].empty()) {
                available_services_history_.erase(si);
            }
        }
    }
}

void routing_manager_client::cleanup_routing_data() {