Method get_requester_policies

implementation/security/src/policy_manager_impl.cpp:1003–1065

}

void policy_manager_impl::get_requester_policies(const std::shared_ptr<policy> _policy,
                                                 std::set<std::shared_ptr<policy>>& _requesters) const {

    std::scoped_lock lock_outer{any_client_policies_mutex_, _policy->mutex_};
    for (const auto& o : _policy->offers_) {
        for (const auto& p : any_client_policies_) {
            if (p == _policy)
                continue;

            std::scoped_lock lock_inner(p->mutex_);

            auto its_policy = std::make_shared<policy>();
            its_policy->credentials_ = p->credentials_;

            for (const auto& r : p->requests_) {
                // o represents an offer by a service interval and its instances
                // (a set of intervals)
                // r represents a request by a service interval and its instances
                // and methods (instance intervals mapped to interval sets of methods)
                //
                // Thus, r matches o if their service identifiers as well as their
                // instances overlap. If r and o match, a new policy must be
                // created that contains the overlapping services/instances mapping
                // of r and o together with the methods from r
                service_t its_o_lower, its_o_upper, its_r_lower, its_r_upper;
                get_bounds(o.first, its_o_lower, its_o_upper);
                get_bounds(r.first, its_r_lower, its_r_upper);

                if (its_o_lower <= its_r_upper && its_r_lower <= its_o_upper) {
                    auto its_service_min = std::max(its_o_lower, its_r_lower);
                    auto its_service_max = std::min(its_r_upper, its_o_upper);

                    for (const auto& i : o.second) {
                        for (const auto& j : r.second) {
                            for (const auto& k : j.second) {
                                instance_t its_i_lower, its_i_upper, its_k_lower, its_k_upper;
                                get_bounds(i, its_i_lower, its_i_upper);
                                get_bounds(k, its_k_lower, its_k_upper);

                                if (its_i_lower <= its_k_upper && its_k_lower <= its_i_upper) {
                                    auto its_instance_min = std::max(its_i_lower, its_k_lower);
                                    auto its_instance_max = std::min(its_i_upper, its_k_upper);

                                    boost::icl::interval_map<instance_t, boost::icl::interval_set<method_t>> its_instances_methods;
                                    its_instances_methods += std::make_pair(
                                            boost::icl::interval<instance_t>::closed(its_instance_min, its_instance_max), j.second);

                                    its_policy->requests_ +=
                                            std::make_pair(boost::icl::interval<instance_t>::closed(its_service_min, its_service_max),
                                                           its_instances_methods);
                                }
                            }
                        }
                    }
                }
            }

            if (!its_policy->requests_.empty()) {