cost_function.h

#ifndef PROBFD_COST_FUNCTION_H
#define PROBFD_COST_FUNCTION_H
 
#include "probfd/type_traits.h"
#include "probfd/types.h"
#include "probfd/value_type.h"
 
namespace probfd {
 
class TerminationInfo {
    bool is_goal_;
    value_t terminal_cost_;
 
    TerminationInfo(bool is_goal, value_t terminal_cost)
        : is_goal_(is_goal)
        , terminal_cost_(terminal_cost)
    {
    }
 
public:
    TerminationInfo() = default;
 
    static TerminationInfo from_goal() { return {true, 0_vt}; }
    static TerminationInfo from_non_goal(value_t value)
    {
        return {false, value};
    }
 
    [[nodiscard]]
    bool is_goal_state() const
    {
        return is_goal_;
    }
 
    [[nodiscard]]
    value_t get_cost() const
    {
        return terminal_cost_;
    }
};
 
template <typename State, typename Action>
class CostFunction {
public:
    virtual ~CostFunction() = default;
 
    virtual TerminationInfo get_termination_info(param_type<State> state) = 0;
 
    virtual value_t get_action_cost(param_type<Action> action) = 0;
};
 
template <typename State, typename Action>
class SimpleCostFunction : public CostFunction<State, Action> {
public:
    TerminationInfo get_termination_info(param_type<State> state) final
    {
        return is_goal(state) ? TerminationInfo::from_goal()
                              : TerminationInfo::from_non_goal(
                                    get_non_goal_termination_cost());
    }
 
    virtual bool is_goal(param_type<State> state) const = 0;
    [[nodiscard]]
    virtual value_t get_non_goal_termination_cost() const = 0;
};
 
} // namespace probfd
 
#endif