Implement non-copying version of Infosets collection

This develops a template that allows us to treat "nested" containers
(such as information sets within players) as a single
flattened container.

As an implication, `GameRep::GetInfosets` now does not create an explicit
array of information sets but rather iterates and generates `GameInfoset` handle
instances only on demand.

Closes #520.

Author: tturocy

src/games/game.h

@@ -901,10 +901,13 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
 
   /// @name Information sets
   //@{
+  using Infosets =
+      NestedElementCollection<&GameRep::m_players, &GamePlayerRep::m_infosets, GameInfoset>;
+
   /// Returns the iset'th information set in the game (numbered globally)
   virtual GameInfoset GetInfoset(int iset) const { throw UndefinedException(); }
   /// Returns the set of information sets in the game
-  virtual std::vector<GameInfoset> GetInfosets() const { throw UndefinedException(); }
+  virtual Infosets GetInfosets() const { throw UndefinedException(); }
   /// Sort the information sets for each player in a canonical order
   virtual void SortInfosets() {}
   /// Returns the set of actions taken by the infoset's owner before reaching this infoset

src/games/gameobject.h

@@ -214,6 +214,124 @@ template <class P, class T> class ElementCollection {
   iterator cend() const { return {m_owner, m_container, (m_owner) ? m_container->size() : 0}; }
 };
 
+template <auto OuterMember, auto InnerMember, typename ValueType> class NestedElementCollection {
+  template <typename MemberPtr> struct outer_element_of;
+
+  template <typename OuterClass, typename Elem>
+  struct outer_element_of<std::vector<std::shared_ptr<Elem>> OuterClass::*> {
+    using outer_class = OuterClass;
+    using outer_elem = Elem;
+    using container = std::vector<std::shared_ptr<Elem>>;
+  };
+
+  template <typename MemberPtr> struct inner_element_of;
+
+  template <typename OuterElem, typename InnerElem>
+  struct inner_element_of<std::vector<std::shared_ptr<InnerElem>> OuterElem::*> {
+    using outer_elem = OuterElem;
+    using inner_elem = InnerElem;
+    using container = std::vector<std::shared_ptr<InnerElem>>;
+  };
+
+  using OM = outer_element_of<decltype(OuterMember)>;
+  using IM = inner_element_of<decltype(InnerMember)>;
+
+  using OuterClass = typename OM::outer_class;
+  using OuterElem = typename OM::outer_elem;
+  using InnerElem = typename IM::inner_elem;
+
+public:
+  class iterator {
+    using outer_iter = typename OM::container::const_iterator;
+    using inner_iter = typename IM::container::const_iterator;
+
+    outer_iter m_outer, m_outerEnd;
+    inner_iter m_inner, m_innerEnd;
+    mutable ValueType m_cache;
+
+    void advance()
+    {
+      while (m_outer != m_outerEnd && m_inner == m_innerEnd) {
+        ++m_outer;
+        if (m_outer != m_outerEnd) {
+          const auto &outerPtr = *m_outer;
+          const auto &innerVec = outerPtr.get()->*InnerMember;
+          m_inner = innerVec.begin();
+          m_innerEnd = innerVec.end();
+        }
+      }
+    }
+
+  public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = ValueType;
+    using difference_type = std::ptrdiff_t;
+    using reference = ValueType;
+    using pointer = const ValueType *;
+
+    iterator() = default;
+
+    iterator(const OuterClass *p_obj, bool p_isEnd)
+    {
+      const auto &outerVec = p_obj->*OuterMember;
+
+      m_outer = outerVec.begin();
+      m_outerEnd = outerVec.end();
+
+      if (p_isEnd || m_outer == m_outerEnd) {
+        m_outer = m_outerEnd;
+        return;
+      }
+
+      const auto &outerPtr = *m_outer;
+      const auto &innerVec = outerPtr.get()->*InnerMember;
+
+      m_inner = innerVec.begin();
+      m_innerEnd = innerVec.end();
+
+      advance();
+    }
+
+    reference operator*() const { return ValueType(*m_inner); }
+
+    pointer operator->() const
+    {
+      m_cache = ValueType(*m_inner);
+      return &m_cache;
+    }
+
+    iterator &operator++()
+    {
+      ++m_inner;
+      advance();
+      return *this;
+    }
+
+    iterator operator++(int)
+    {
+      iterator tmp = *this;
+      ++(*this);
+      return tmp;
+    }
+
+    bool operator==(const iterator &p_other) const
+    {
+      return m_outer == p_other.m_outer && (m_outer == m_outerEnd || m_inner == p_other.m_inner);
+    }
+
+    bool operator!=(const iterator &p_other) const { return !(*this == p_other); }
+  };
+
+private:
+  const OuterClass *m_obj;
+
+public:
+  explicit NestedElementCollection(const OuterClass *p_obj) : m_obj(p_obj) {}
+
+  iterator begin() const { return {m_obj, false}; }
+  iterator end() const { return {m_obj, true}; }
+};
+
 } // end namespace Gambit
 
 #endif // GAMBIT_GAMES_GAMEOBJECT_H

src/games/gametree.cc

@@ -1193,15 +1193,6 @@ GameInfoset GameTreeRep::GetInfoset(int p_index) const
   throw std::out_of_range("Infoset index out of range");
 }
 
-std::vector<GameInfoset> GameTreeRep::GetInfosets() const
-{
-  std::vector<GameInfoset> infosets;
-  for (const auto &player : m_players) {
-    std::copy(player->m_infosets.begin(), player->m_infosets.end(), std::back_inserter(infosets));
-  }
-  return infosets;
-}
-
 //------------------------------------------------------------------------
 //                        GameTreeRep: Outcomes
 //------------------------------------------------------------------------

src/games/gametree.h

@@ -127,7 +127,7 @@ class GameTreeRep : public GameExplicitRep {
   /// Returns the iset'th information set in the game (numbered globally)
   GameInfoset GetInfoset(int iset) const override;
   /// Returns the set of information sets in the game
-  std::vector<GameInfoset> GetInfosets() const override;
+  Infosets GetInfosets() const override { return Infosets(this); }
   /// Sort the information sets for each player in a canonical order
   void SortInfosets() override;
   /// Returns the set of actions taken by the infoset's owner before reaching this infoset