task_proxy.h

#ifndef PROBFD_TASK_PROXY_H
#define PROBFD_TASK_PROXY_H
 
#include "probfd/value_type.h"
 
#include "downward/operator_id.h"
 
#include "downward/task_proxy.h"
 
// Forward Declarations
namespace probfd {
class ProbabilisticEffectProxy;
class ProbabilisticEffectConditionsProxy;
class ProbabilisticEffectsProxy;
 
class ProbabilisticOperatorProxy;
class ProbabilisticOperatorsProxy;
 
class ProbabilisticOutcomeProxy;
class ProbabilisticOutcomesProxy;
 
class ProbabilisticTaskProxy;
class ProbabilisticTask;
} // namespace probfd
 
namespace probfd::causal_graph {
class ProbabilisticCausalGraph;
}
 
namespace probfd {
 
class ProbabilisticEffectConditionsProxy
    : public ProxyCollection<ProbabilisticEffectConditionsProxy> {
    const ProbabilisticTask* task_;
 
    int op_index_;
    int outcome_index_;
    int eff_index_;
 
public:
    ProbabilisticEffectConditionsProxy(
        const ProbabilisticTask& task,
        int op_index,
        int outcome_index,
        int eff_index);
 
    [[nodiscard]]
    std::size_t size() const;
 
    FactProxy operator[](std::size_t index) const;
};
 
class ProbabilisticEffectProxy {
    const ProbabilisticTask* task_;
    int op_index_;
    int outcome_index_;
    int eff_index_;
 
public:
    ProbabilisticEffectProxy(
        const ProbabilisticTask& task,
        int op_index,
        int outcome_index,
        int eff_index);
 
    [[nodiscard]]
    ProbabilisticEffectConditionsProxy get_conditions() const;
 
    [[nodiscard]]
    FactProxy get_fact() const;
};
 
class ProbabilisticEffectsProxy
    : public ProxyCollection<ProbabilisticEffectsProxy> {
    const ProbabilisticTask* task_;
    int op_index_;
    int outcome_index_;
 
public:
    ProbabilisticEffectsProxy(
        const ProbabilisticTask& task,
        int op_index,
        int outcome_index);
 
    [[nodiscard]]
    std::size_t size() const;
 
    ProbabilisticEffectProxy operator[](std::size_t eff_index) const;
};
 
class ProbabilisticOutcomeProxy {
    const ProbabilisticTask* task_;
    int op_index_;
    int outcome_index_;
 
public:
    ProbabilisticOutcomeProxy(
        const ProbabilisticTask& task,
        int op_index,
        int outcome_index);
 
    [[nodiscard]]
    int get_determinization_id() const;
 
    [[nodiscard]]
    ProbabilisticOperatorProxy get_operator() const;
 
    [[nodiscard]]
    ProbabilisticEffectsProxy get_effects() const;
 
    [[nodiscard]]
    value_t get_probability() const;
};
 
class ProbabilisticOutcomesProxy
    : public ProxyCollection<ProbabilisticOutcomesProxy> {
    const ProbabilisticTask* task_;
    int op_index_;
 
public:
    ProbabilisticOutcomesProxy(const ProbabilisticTask& task, int op_index);
 
    [[nodiscard]]
    ProbabilisticOperatorProxy get_operator() const;
 
    [[nodiscard]]
    std::size_t size() const;
 
    ProbabilisticOutcomeProxy operator[](std::size_t eff_index) const;
};
 
class ProbabilisticOperatorProxy : public PartialOperatorProxy {
public:
    ProbabilisticOperatorProxy(const ProbabilisticTask& task, int index);
 
    [[nodiscard]]
    ProbabilisticOutcomesProxy get_outcomes() const;
 
    [[nodiscard]]
    value_t get_cost() const;
};
 
class ProbabilisticOperatorsProxy
    : public ProxyCollection<ProbabilisticOperatorsProxy> {
    const ProbabilisticTask* task_;
 
public:
    explicit ProbabilisticOperatorsProxy(const ProbabilisticTask& task);
 
    [[nodiscard]]
    std::size_t size() const;
 
    ProbabilisticOperatorProxy operator[](std::size_t index) const;
 
    ProbabilisticOperatorProxy operator[](OperatorID id) const;
};
 
class ProbabilisticTaskProxy : public PlanningTaskProxy {
public:
    explicit ProbabilisticTaskProxy(const ProbabilisticTask& task);
 
    [[nodiscard]]
    ProbabilisticOperatorsProxy get_operators() const;
 
    const causal_graph::ProbabilisticCausalGraph& get_causal_graph() const;
};
 
bool does_fire(const ProbabilisticEffectProxy& effect, const State& state);
 
} // namespace probfd
 
#endif