Refactor BuildInfosetParents defining the position using ActiveEdge

Author: d-kad

src/games/game.h

@@ -57,82 +57,6 @@ using GameNode = GameObjectPtr<GameNodeRep>;
 class GameRep;
 using Game = std::shared_ptr<GameRep>;
 
-template <class P, class T> class ElementCollection {
-  P m_owner{nullptr};
-  const std::vector<T *> *m_container{nullptr};
-
-public:
-  class iterator {
-    P m_owner{nullptr};
-    const std::vector<T *> *m_container{nullptr};
-    size_t m_index{0};
-
-  public:
-    using iterator_category = std::bidirectional_iterator_tag;
-    using difference_type = std::ptrdiff_t;
-    using value_type = GameObjectPtr<T>;
-    using pointer = value_type *;
-    using reference = value_type &;
-
-    iterator() = default;
-    iterator(const P &p_owner, const std::vector<T *> *p_container, size_t p_index = 0)
-      : m_owner(p_owner), m_container(p_container), m_index(p_index)
-    {
-    }
-    iterator(const iterator &) = default;
-    ~iterator() = default;
-    iterator &operator=(const iterator &) = default;
-
-    bool operator==(const iterator &p_iter) const
-    {
-      return m_owner == p_iter.m_owner && m_container == p_iter.m_container &&
-             m_index == p_iter.m_index;
-    }
-    bool operator!=(const iterator &p_iter) const
-    {
-      return m_owner != p_iter.m_owner || m_container != p_iter.m_container ||
-             m_index != p_iter.m_index;
-    }
-
-    iterator &operator++()
-    {
-      m_index++;
-      return *this;
-    }
-    iterator &operator--()
-    {
-      m_index--;
-      return *this;
-    }
-    value_type operator*() const { return m_container->at(m_index); }
-    const P &GetOwner() const { return m_owner; }
-  };
-
-  ElementCollection() = default;
-  explicit ElementCollection(const P &p_owner, const std::vector<T *> *p_container)
-    : m_owner(p_owner), m_container(p_container)
-  {
-  }
-  ElementCollection(const ElementCollection<P, T> &) = default;
-  ~ElementCollection() = default;
-  ElementCollection &operator=(const ElementCollection<P, T> &) = default;
-
-  bool operator==(const ElementCollection<P, T> &p_other) const
-  {
-    return m_owner == p_other.m_owner && m_container == p_other.m_container;
-  }
-
-  bool empty() const { return m_container->empty(); }
-  size_t size() const { return m_container->size(); }
-  GameObjectPtr<T> front() const { return m_container->front(); }
-  GameObjectPtr<T> back() const { return m_container->back(); }
-
-  iterator begin() const { return {m_owner, m_container, 0}; }
-  iterator end() const { return {m_owner, m_container, (m_owner) ? m_container->size() : 0}; }
-  iterator cbegin() const { return {m_owner, m_container, 0}; }
-  iterator cend() const { return {m_owner, m_container, (m_owner) ? m_container->size() : 0}; }
-};
-
 //
 // Forward declarations of classes defined elsewhere.
 //
@@ -491,17 +415,23 @@ class GameNodeRep : public std::enable_shared_from_this<GameNodeRep> {
   /// @brief A range class for iterating over a node's (action, child) pairs.
   class Actions {
   private:
-    GameNode m_owner{nullptr};
+    const GameNodeRep *m_owner{nullptr};
 
   public:
     class iterator;
 
-    Actions(const GameNode p_owner);
+    Actions(const GameNodeRep *p_owner);
 
     iterator begin() const;
     iterator end() const;
   };
 
+  GameNodeRep(GameRep *e, GameNodeRep *p);
+  ~GameNodeRep();
+
+  bool IsValid() const { return m_valid; }
+  void Invalidate() { m_valid = false; }
+
   /// @brief Returns a collection for iterating over this node's (action, child) pairs.
   Actions GetActions() const;
 
@@ -601,9 +531,9 @@ class GameNodeRep::Actions::iterator {
   GameNode GetOwner() const;
 };
 
-inline GameNodeRep::Actions::Actions(GameNode p_owner) : m_owner(p_owner) {}
+inline GameNodeRep::Actions::Actions(const GameNodeRep *p_owner) : m_owner(p_owner) {}
 
-inline GameNodeRep::Actions GameNodeRep::GetActions() const { return Actions(this); }
+inline GameNodeRep::Actions GameNodeRep::GetActions() const { return {Actions(this)}; }
 
 inline GameNodeRep::Actions::iterator GameNodeRep::Actions::begin() const
 {

src/games/gameobject.h

@@ -142,7 +142,7 @@ template <class P, class T> class ElementCollection {
     }
     value_type operator*() const { return m_container->at(m_index); }
 
-    inline P& GetOwner() const { return m_owner; }
+    inline const P& GetOwner() const { return m_owner; }
   };
 
   ElementCollection() = default;

src/games/gametree.cc

@@ -899,7 +899,7 @@ void GameTreeRep::BuildInfosetParents()
   prior_actions[GamePlayer(m_chance)].emplace(nullptr);
 
   position.emplace(m_root->GetActions().begin());
-  prior_actions[m_root->m_infoset->m_player].emplace(nullptr);
+  prior_actions[m_root->GetPlayer()].emplace(nullptr);
   if (m_root->m_infoset) {
     m_infosetParents[m_root->m_infoset].insert(nullptr);
   }
@@ -914,15 +914,15 @@ void GameTreeRep::BuildInfosetParents()
       node = current_it.GetOwner();
 
       if (current_it == node->GetActions().end()) {
-        prior_actions.at(node->m_infoset->m_player).pop();
+        prior_actions.at(node->GetPlayer()).pop();
         position.pop();
-        path_choices.erase(node->m_infoset);
+        path_choices.erase(node->GetInfoset());
         continue;
       }
       else {
         std::tie(action, child) = *current_it;
         ++current_it;
-        path_choices[node->m_infoset] = action;
+        path_choices[node->GetInfoset()] = action;
       }
     }
     else {
@@ -931,15 +931,15 @@ void GameTreeRep::BuildInfosetParents()
       child = node->GetChild(action);
     }
 
-    prior_actions.at(node->m_infoset->m_player).top() = action;
+    prior_actions.at(node->GetPlayer()).top() = action;
 
     if (!child->IsTerminal()) {
-      auto child_player = child->m_infoset->m_player;
+      auto child_player = child->GetPlayer();
       auto prior_action = prior_actions.at(child_player).top();
-      m_infosetParents[child->m_infoset].insert(prior_action);
+      m_infosetParents[child->m_infoset].insert(prior_action ? prior_action.get() : nullptr);
 
-      if (path_choices.find(child->m_infoset) != path_choices.end()) {
-        const GameAction replay_action = path_choices.at(child->m_infoset);
+      if (path_choices.find(child->GetInfoset()) != path_choices.end()) {
+        const GameAction replay_action = path_choices.at(child->GetInfoset());
         position.emplace(AbsentMindedEdge{replay_action, child});
       }
       else {