state.h

 
#ifndef SYMBOLIC_STATE_H_
#define SYMBOLIC_STATE_H_
 
#define SYMBOLIC_STATE_USE_SET
 
#include <Eigen/Eigen>
#include <exception>      // std::exception
#include <functional>     // std::hash
#include <optional>       // std::optional
#include <ostream>        // std::ostream
#include <unordered_map>  // std::unordered_map
#include <unordered_set>  // std::unordered_set
#include <utility>        // std::pair
 
#ifndef SYMBOLIC_STATE_USE_SET
#include "symbolic/utils/unique_vector.h"
#else  // SYMBOLIC_STATE_USE_SET
#include "symbolic/utils/hash_set.h"
#endif  // SYMBOLIC_STATE_USE_SET
 
#include "symbolic/proposition.h"
 
namespace symbolic {
 
class Predicate;
 
#ifndef SYMBOLIC_STATE_USE_SET
class State : private UniqueVector<Proposition> {
  using Base = UniqueVector<Proposition>;
#else   // SYMBOLIC_STATE_USE_SET
class State : private HashSet<Proposition> {
  using Base = HashSet<Proposition>;
#endif  // SYMBOLIC_STATE_USE_SET
 
 public:
  using iterator = Base::iterator;
  using const_iterator = Base::const_iterator;
 
  State() = default;
  State(std::initializer_list<Proposition> l) : Base(l){};
 
  State(const Pddl& pddl, const std::unordered_set<std::string>& str_state);
 
  bool contains(const PropositionBase& prop) const {
    return Base::contains(prop);
  }
 
  bool insert(const PropositionBase& prop) { return Base::insert(prop); }
  bool insert(Proposition&& prop) { return Base::insert(std::move(prop)); }
 
  template <class InputIt>
  bool insert(InputIt first, InputIt last);
 
  template <class... Args>
  bool emplace(Args&&... args) {
    return insert(Proposition(args...));
  }
 
  bool erase(const PropositionBase& prop) { return Base::erase(prop); }
 
  const_iterator begin() const { return Base::begin(); }
  const_iterator end() const { return Base::end(); };
 
  iterator begin() { return Base::begin(); }
  iterator end() { return Base::end(); }
 
  bool empty() const { return Base::empty(); }
  size_t size() const { return Base::size(); }
 
#ifndef SYMBOLIC_STATE_USE_SET
  void reserve(size_t size) { static_cast<Base&>(*this).reserve(size); }
#else   // SYMBOLIC_STATE_USE_SET
  void reserve(size_t size) {}
#endif  // SYMBOLIC_STATE_USE_SET
 
  std::unordered_set<std::string> Stringify() const;
 
  friend bool operator==(const State& lhs, const State& rhs) {
    return static_cast<const Base&>(lhs) == static_cast<const Base&>(rhs);
  }
  friend bool operator!=(const State& lhs, const State& rhs) {
    return !(lhs == rhs);
  }
 
  friend bool operator<(const State& lhs, const State& rhs) {
    return static_cast<const Base&>(lhs) < static_cast<const Base&>(rhs);
  }
 
  friend std::ostream& operator<<(std::ostream& os, const State& state);
};
 
template <class InputIt>
bool State::insert(InputIt first, InputIt last) {
  // TODO(tmigimatsu): More efficient way of inserting
  bool is_changed = false;
  for (InputIt it = first; it != last; ++it) {
    is_changed |= insert(*it);
  }
  return is_changed;
}
 
class PartialState {
 public:
  class UnknownEvaluation : public std::exception {
   public:
    explicit UnknownEvaluation(const PropositionBase& prop)
        : prop_(prop), str_prop_(prop.to_string()) {}
 
    const char* what() const noexcept override { return str_prop_.c_str(); }
 
    const Proposition& proposition() const { return prop_; }
 
   private:
    const Proposition prop_;
    const std::string str_prop_;
  };
 
  PartialState() = default;
 
  PartialState(const State& pos, const State& neg) : pos_(pos), neg_(neg) {}
 
  PartialState(State&& pos, State&& neg)
      : pos_(std::move(pos)), neg_(std::move(neg)) {}
 
  PartialState(const Pddl& pddl, const std::unordered_set<std::string>& str_pos,
               const std::unordered_set<std::string>& str_neg)
      : pos_(pddl, str_pos), neg_(pddl, str_neg) {}
 
  const State& pos() const { return pos_; }
  State& pos() { return pos_; }
 
  const State& neg() const { return neg_; }
  State& neg() { return neg_; }
 
  bool empty() const { return pos_.empty() && neg_.empty(); }
  size_t size() const { return pos_.size() + neg_.size(); }
 
  bool contains(const PropositionBase& prop) const;
  bool does_not_contain(const PropositionBase& prop) const;
 
  int insert(const PropositionBase& prop);
  int insert(Proposition&& prop);
 
  template <class... Args>
  int emplace(Args&&... args) {
    return insert(Proposition(args...));
  }
 
  int erase(const PropositionBase& prop);
  int erase(Proposition&& prop);
 
  bool IsConsistent() const;
 
  std::pair<std::unordered_set<std::string>, std::unordered_set<std::string>>
  Stringify() const;
 
  friend bool operator==(const PartialState& lhs, const PartialState& rhs) {
    return lhs.pos_ == rhs.pos_ && lhs.neg_ == rhs.neg_;
  }
 
  friend bool operator!=(const PartialState& lhs, const PartialState& rhs) {
    return lhs.pos_ != rhs.pos_ || lhs.neg_ != rhs.neg_;
  }
 
  friend bool operator<(const PartialState& lhs, const PartialState& rhs) {
    return std::tie(lhs.pos_, lhs.neg_) < std::tie(rhs.pos_, rhs.neg_);
  }
 
  friend std::ostream& operator<<(std::ostream& os, const PartialState& state);
 
 private:
  State pos_;
  State neg_;
};
 
class StateIndex {
 public:
  class iterator;
  using IndexedState = Eigen::Array<bool, Eigen::Dynamic, 1>;
 
  explicit StateIndex(const std::vector<Predicate>& predicates,
                      bool use_cache = true);
 
  Proposition GetProposition(size_t idx_proposition) const;
 
  size_t GetPropositionIndex(const Proposition& prop) const;
 
  State GetState(Eigen::Ref<const IndexedState> indexed_state) const;
 
  IndexedState GetIndexedState(const State& state) const;
 
  size_t size() const { return idx_predicate_group_.back(); }
 
  // Iterators
  iterator begin() const { return iterator(this, 0); };
  iterator end() const { return iterator(this, size()); };
 
  const Pddl& pddl() const { return *pddl_; }
 
 private:
  const Pddl* pddl_ = nullptr;
 
  // Predicates vector stored for portability
  std::vector<Predicate> predicates_;
 
  // Sorted vector of predicate group indices in indexed state (beginning of
  // predicate group)
  std::vector<size_t> idx_predicate_group_;
 
  // Map from predicate to index in predicates vector
  std::unordered_map<std::string, size_t> idx_predicates_;
 
  // Cache
  mutable std::unordered_map<size_t, Proposition> cache_propositions_;
  mutable std::unordered_map<std::string, size_t> cache_idx_propositions_;
 
  bool use_cache_;
 
 public:
  class iterator {
   public:
    // Iterator traits
    using iterator_category = std::random_access_iterator_tag;
    using value_type = Proposition;
    using difference_type = ptrdiff_t;
    using pointer = const Proposition*;
    using reference = const Proposition&;
 
    // Constructor
    iterator(const StateIndex* state_index, int idx)
        : state_index_(state_index), idx_(idx) {}
 
    // Forward iterator
    iterator& operator++() { return operator+=(1); }
 
    iterator operator++(int) {
      iterator it = *this;
      operator++();
      return it;
    }
 
    reference operator*() const {
      prop_ = state_index_->GetProposition(idx_);
      return prop_;
    };
 
    pointer operator->() const {
      prop_ = state_index_->GetProposition(idx_);
      return &prop_;
    }
 
    bool operator==(const iterator& rhs) const {
      return state_index_ == rhs.state_index_ && idx_ == rhs.idx_;
    }
 
    bool operator!=(const iterator& rhs) const { return !(*this == rhs); }
 
    // Bidirectional iterator
    iterator& operator--() { return operator+=(-1); }
 
    iterator operator--(int) {
      iterator it = *this;
      operator--();
      return it;
    }
 
    // Random access iterator
    bool operator<(const iterator& rhs) const {
      return state_index_ == rhs.state_index_ && idx_ < rhs.idx_;
    }
 
    bool operator>(const iterator& rhs) const { return rhs < *this; };
 
    bool operator<=(const iterator& rhs) const {
      return state_index_ == rhs.state_index_ && idx_ <= rhs.idx_;
    }
 
    bool operator>=(const iterator& rhs) const { return rhs <= *this; };
 
    iterator& operator+=(difference_type n) {
      idx_ += n;
      return *this;
    }
 
    iterator operator+(difference_type n) const {
      iterator temp = *this;
      return temp += n;
    }
 
    friend iterator operator+(difference_type n, const iterator& it) {
      return it + n;
    }
 
    iterator& operator-=(difference_type n) { return operator+=(-n); }
 
    iterator operator-(difference_type n) const {
      iterator temp = *this;
      return temp -= n;
    }
 
    difference_type operator-(const iterator& rhs) const {
      return idx_ - rhs.idx_;
    }
 
    value_type operator[](difference_type n) const { return *(operator+(n)); }
 
   private:
    const StateIndex* state_index_ = nullptr;
    int idx_ = 0;
    mutable Proposition prop_;
  };
};
 
}  // namespace symbolic
 
namespace std {
 
template <>
struct hash<symbolic::State> {
  size_t operator()(const symbolic::State& state) const noexcept;
};
 
}  // namespace std
 
#endif  // SYMBOLIC_STATE_H_