Method del_routing_info

implementation/routing/src/routing_manager_impl.cpp:1762–1843

}

void routing_manager_impl::del_routing_info(service_t _service, instance_t _instance, bool _has_reliable, bool _has_unreliable,
                                            bool _trigger_availability) {

    std::shared_ptr<serviceinfo> its_info(find_service(_service, _instance));
    if (!its_info)
        return;

    if (_trigger_availability) {
        stub_->on_stop_offer_service(VSOMEIP_ROUTING_CLIENT, _service, _instance, its_info->get_major(), its_info->get_minor());
    }

    // Implicit unsubscribe

    std::vector<std::shared_ptr<event>> its_events;
    {
        // Acquire event_registration_mutex_ before eventgroups_mutex_ to serialize with
        // subscribe()/on_subscribe_ack() and atomically clear subscribers with the service removal.
        std::scoped_lock its_reg_lock{event_registration_mutex_};
        std::scoped_lock its_lock{eventgroups_mutex_};
        const auto search = eventgroups_.find(service_instance_t{_service, _instance});

        if (search != eventgroups_.end()) {
            for (const auto& [eventgroup_id, eventgroup_info] : search->second) {
                // As the service is gone, all subscriptions to its events
                // do no longer exist and the last received payload is no
                // longer valid.
                for (auto& its_event : eventgroup_info->get_events()) {
                    const auto its_subscribers = its_event->get_subscribers();
                    for (const auto its_subscriber : its_subscribers) {
                        its_event->remove_subscriber(eventgroup_id, its_subscriber);
                    }
                    its_events.push_back(its_event);
                }
            }
        }
    }

    for (const auto& e : its_events) {
        if (e->is_set()) {
            VSOMEIP_INFO_P << "Unsetting payload for [" << hex4(_service) << "." << hex4(_instance) << "." << hex4(e->get_event()) << "]";
        }
        e->unset_payload(true);
    }

    {
        std::scoped_lock its_lock{remote_subscription_state_mutex_};
        std::set<std::tuple<service_t, instance_t, eventgroup_t, client_t>> its_invalid;

        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)
            remote_subscription_state_.erase(its_key);
    }