Method cleanup_subscriber

implementation/routing/src/routing_manager_client.cpp:2409–2448

}

void routing_manager_client::cleanup_subscriber(std::scoped_lock<std::mutex> const& _provider_lock) {
    // Tracks unique (service, instance, eventgroup, client) tuples for which
    // the user notification and table invalidation must fire exactly once.
    struct sub_tuple {
        service_t service;
        instance_t instance;
        eventgroup_t eventgroup;
        client_t client;
        auto operator<=>(const sub_tuple&) const = default;
    };
    std::set<sub_tuple> unique_tuples;

    for (auto const& [si, evs] : provided_events_) {
        auto const service = si.service();
        auto const instance = si.instance();
        for (auto const& [event_id, event] : evs) {
            for (auto const group : event->get_eventgroups()) {
                for (auto const client : event->get_subscribers(group)) {
                    // Per-event routing state mutation — fine to call once per event.
                    unsubscribe_base(client, service, instance, group, event_id, _provider_lock);
                    unique_tuples.insert({service, instance, group, client});
                }
            }
        }
    }

    // Per unique (svc, inst, group, client): invalidate all table entries
    // (ANY_EVENT expansion covers both ANY_EVENT and specific-event subscriptions)
    // and notify the user exactly once.
    for (auto const& [service, instance, group, client] : unique_tuples) {
        auto ep = ep_mgr_->find_local_server_endpoint(client);
        auto const env = ep ? ep->get_env() : "";
        auto const sec = ep ? ep->get_sec_client() : vsomeip_sec_client_t{};
        VSOMEIP_INFO << "UNSUBSCRIBE(" << hex4(client) << "): [" << hex4(service) << "." << hex4(instance) << "." << hex4(group) << "."
                     << hex4(ANY_EVENT) << "]";
        host_->on_subscription(service, instance, group, client, &sec, env, false, [](bool) {
            // no need to execute anything, as the endpoint token is invalidated as well
        });
    }
}

client_t routing_manager_client::get_client_by_address(const boost::asio::ip::address& _address, port_t _port) const {
    std::scoped_lock lock{consumer_mutex_};