Method stop

implementation/routing/src/routing_manager_client.cpp:176–242

}

void routing_manager_client::stop() {
    state_machine_->target_shutdown();
    ep_mgr_->stop();
    // Transition to ST_DEREGISTERED so that a subsequent start() finds a clean state.
    // The error handler is suppressed because shall_run_ = false (target_shutdown was called above).
    {
        std::scoped_lock its_sender_lock{sender_mutex_};
        // transition the state under the sender mutex, as this is the one protecting the restart sequence
        state_machine_->deregistered();
        if (sender_) {
            VSOMEIP_INFO_P << "starting to flush the sender";
            sender_->start_flushing();
        }
    }

    {
        std::scoped_lock its_lock{consumer_mutex_};
        request_debounce_timer_.cancel();
    }

    {
        std::scoped_lock its_receiver_lock(receiver_mutex_);
        auto stop_and_clear = [](auto& receiver) {
            if (receiver) {
                receiver->stop();
                receiver = nullptr;
            }
        };
        stop_and_clear(tcp_receiver_);
        stop_and_clear(uds_receiver_);
    }

    {
        std::scoped_lock its_lock{log_timer_mutex_};
        version_log_timer_.cancel();
        status_log_timer_.cancel();
    }
    if (!ep_mgr_->await_stopped(std::chrono::milliseconds(500))) {
        VSOMEIP_WARNING_P << "Not all endpoints could be flushed within time";
        ep_mgr_->clear_consumer_endpoints();
        ep_mgr_->clear_provider_endpoints();
    }
    {
        std::unique_lock its_lock(sender_mutex_);
        if (sender_) {
            if (!sender_cv_.wait_for(its_lock, std::chrono::milliseconds(500), [this] { return !sender_; })) {
                VSOMEIP_WARNING << "rmc::stop sender was not flushed successfully";
                // sender is not null, since the predicate is still true
                sender_->stop(true);
                // delete the sender
                sender_ = nullptr;
            }
        }
    }
    {
        // By now all endpoints have been stopped
        // -> all still queued continuations will be marked "stale"
        std::scoped_lock its_lock(provider_mutex_);