Method on_availability

implementation/runtime/src/application_impl.cpp:1411–1524

}

void application_impl::on_availability(service_t _service, instance_t _instance, availability_state_e _state, major_version_t _major,
                                       minor_version_t _minor) {

    std::vector<availability_state_handler_t> its_handlers;
    {
        std::scoped_lock availability_lock{availability_mutex_};
        if (_state == is_available_unlocked(_service, _instance, _major, _minor)) {
            return;
        }

        if (_state != availability_state_e::AS_UNAVAILABLE) {
            available_[_service][_instance][_major] = std::make_pair(_minor, _state);
        } else {
            auto found_available_service = available_.find(_service);
            if (found_available_service != available_.end()) {
                auto found_instance = found_available_service->second.find(_instance);
                if (found_instance != found_available_service->second.end()) {
                    auto found_major = found_instance->second.find(_major);
                    if (found_major != found_instance->second.end()) {
                        if (_minor == found_major->second.first)
                            found_available_service->second.erase(_instance);
                    }
                }
            }
        }

        auto find_matching_handler = [&](availability_major_minor_t& _av_ma_mi_it) {
            auto found_major = _av_ma_mi_it.find(_major);
            if (found_major != _av_ma_mi_it.end()) {
                for (std::int32_t mi = static_cast<std::int32_t>(_minor); mi >= 0; mi--) {
                    auto found_minor = found_major->second.find(static_cast<minor_version_t>(mi));
                    if (found_minor != found_major->second.end()) {
                        if (get_availability_state(found_minor->second.second, _service, _instance, _major, _minor) != _state) {
                            its_handlers.push_back(found_minor->second.first);
                            set_availability_state(found_minor->second.second, _service, _instance, _major, _minor, _state);
                        }
                    }
                }
                auto found_any_minor = found_major->second.find(ANY_MINOR);
                if (found_any_minor != found_major->second.end()) {
                    if (get_availability_state(found_any_minor->second.second, _service, _instance, _major, _minor) != _state) {
                        its_handlers.push_back(found_any_minor->second.first);
                        set_availability_state(found_any_minor->second.second, _service, _instance, _major, _minor, _state);
                    }
                }
            }
            found_major = _av_ma_mi_it.find(ANY_MAJOR);
            if (found_major != _av_ma_mi_it.end()) {
                for (std::int32_t mi = static_cast<std::int32_t>(_minor); mi >= 0; mi--) {
                    auto found_minor = found_major->second.find(static_cast<minor_version_t>(mi));
                    if (found_minor != found_major->second.end()) {
                        if (get_availability_state(found_minor->second.second, _service, _instance, _major, _minor) != _state) {
                            its_handlers.push_back(found_minor->second.first);
                            set_availability_state(found_minor->second.second, _service, _instance, _major, _minor, _state);
                        }
                    }
                }
                auto found_any_minor = found_major->second.find(ANY_MINOR);