rule.hpp

Go to the documentation of this file.

#pragma once
 
#include "condition.hpp"
#include "property.hpp"
#include <jaffarCommon/json.hpp>
#include <set>
#include <vector>
 
namespace jaffarPlus
{
 
class Rule final
{
public:
  typedef size_t label_t;
 
  Rule(const size_t index, const label_t label) : _index(index), _label(label) {};
  ~Rule() = default;
 
  // The rule is achieved only if all conditions are met
  __INLINE__ bool evaluate() const
  {
    for (const auto& c : _conditions)
      if (c->evaluate() == false) return false;
    return true;
  }
 
  void setReward(const float reward) { _reward = reward; }
  void setWinRule(const bool isWinRule) { _isWinRule = isWinRule; }
  void setFailRule(const bool isFailRule) { _isFailRule = isFailRule; }
  void setCheckpointRule(const bool isCheckpointRule) { _isCheckpointRule = isCheckpointRule; }
  void setCheckpointTolerance(const size_t checkPointTolerance) { _checkPointTolerance = checkPointTolerance; }
  void setSaveSolutionRule(const bool isSaveSolutionRule) { _isSaveSolutionRule = isSaveSolutionRule; }
  void setSaveSolutionPath(const std::string& saveSolutionPath) { _saveSolutionPath = saveSolutionPath; }
  void addAction(const std::function<void()>& function) { _actions.push_back(function); }
  void addCondition(std::unique_ptr<Condition> condition) { _conditions.insert(std::move(condition)); }
  void addSatisfyRuleLabel(const label_t satisfyRuleLabel) { _satisfyRuleLabels.insert(satisfyRuleLabel); }
  void addSatisfyRule(Rule* const subRule) { _satisfyRules.push_back(subRule); }
 
  label_t getLabel() const { return _label; }
  float getReward() const { return _reward; }
  bool isWinRule() const { return _isWinRule; }
  bool isFailRule() const { return _isFailRule; }
  bool isCheckpointRule() const { return _isCheckpointRule; }
  size_t getCheckpointTolerance() const { return _checkPointTolerance; }
  bool isSaveSolutionRule() const { return _isSaveSolutionRule; }
  const std::string& getSaveSolutionPath() const { return _saveSolutionPath; }
  const std::unordered_set<label_t>& getSatisfyRuleLabels() const { return _satisfyRuleLabels; }
  const std::vector<Rule*>& getSatisfyRules() const { return _satisfyRules; }
  size_t getIndex() const { return _index; }
  const std::vector<std::function<void()>>& getActions() const { return _actions; }
 
private:
  // Conditions are evaluated frequently, so this optimized for performance
  // Operands are pre-parsed as pointers/immediates and the evaluation function
  // is a template that is created at compilation time.
  std::unordered_set<std::unique_ptr<Condition>> _conditions;
 
  const size_t _index;
 
  const label_t _label;
 
  float _reward = 0.0;
 
  // Special condition flags
  bool        _isWinRule           = false; 
  bool        _isFailRule          = false; 
  bool        _isCheckpointRule    = false; 
  size_t      _checkPointTolerance = 0;     
  bool        _isSaveSolutionRule  = false; 
  std::string _saveSolutionPath;            
 
  std::unordered_set<label_t> _satisfyRuleLabels;
 
  std::vector<Rule*> _satisfyRules;
 
  std::vector<std::function<void()>> _actions;
};
 
} // namespace jaffarPlus