Convert player ownership model to shared_ptr

Author: tturocy

src/games/game.cc

@@ -42,7 +42,7 @@ namespace Gambit {
 GameOutcomeRep::GameOutcomeRep(GameRep *p_game, int p_number) : m_game(p_game), m_number(p_number)
 {
   for (const auto &player : m_game->m_players) {
-    m_payoffs[player] = Number();
+    m_payoffs[player.get()] = Number();
   }
 }
 
@@ -52,7 +52,7 @@ GameOutcomeRep::GameOutcomeRep(GameRep *p_game, int p_number) : m_game(p_game),
 
 GameAction GameStrategyRep::GetAction(const GameInfoset &p_infoset) const
 {
-  if (p_infoset->GetPlayer() != m_player) {
+  if (p_infoset->GetPlayer().get() != m_player) {
     throw MismatchException();
   }
   const int action = m_behav[p_infoset->GetNumber()];
@@ -366,7 +366,7 @@ MixedStrategyProfile<T>::operator=(const MixedStrategyProfile<T> &p_profile)
 //             MixedStrategyProfile<T>: General data access
 //========================================================================
 
-template <class T> Vector<T> MixedStrategyProfile<T>::operator[](const GamePlayer &p_player) const
+template <class T> Vector<T> MixedStrategyProfile<T>::GetStrategy(const GamePlayer &p_player) const
 {
   CheckVersion();
   auto strategies = m_rep->m_support.GetStrategies(p_player);

src/games/game.h

@@ -49,7 +49,7 @@ class GameStrategyRep;
 using GameStrategy = GameObjectPtr<GameStrategyRep>;
 
 class GamePlayerRep;
-using GamePlayer = GameObjectPtr<GamePlayerRep>;
+using GamePlayer = GameObjectSmartPtr<GamePlayerRep>;
 
 class GameNodeRep;
 using GameNode = GameObjectPtr<GameNodeRep>;
@@ -132,6 +132,81 @@ template <class P, class T> class ElementCollection {
   iterator cend() const { return {m_owner, m_container, (m_owner) ? m_container->size() : 0}; }
 };
 
+template <class P, class T> class SmartElementCollection {
+  P m_owner{nullptr};
+  const std::vector<std::shared_ptr<T>> *m_container{nullptr};
+
+public:
+  class iterator {
+    P m_owner{nullptr};
+    const std::vector<std::shared_ptr<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 = GameObjectSmartPtr<T>;
+    using pointer = value_type *;
+    using reference = value_type &;
+
+    iterator() = default;
+    iterator(const P &p_owner, const std::vector<std::shared_ptr<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); }
+  };
+
+  SmartElementCollection() = default;
+  explicit SmartElementCollection(const P &p_owner,
+                                  const std::vector<std::shared_ptr<T>> *p_container)
+    : m_owner(p_owner), m_container(p_container)
+  {
+  }
+  SmartElementCollection(const SmartElementCollection<P, T> &) = default;
+  ~SmartElementCollection() = default;
+  SmartElementCollection &operator=(const SmartElementCollection<P, T> &) = default;
+
+  bool operator==(const SmartElementCollection<P, T> &p_other) const
+  {
+    return m_owner == p_other.m_owner && m_container == p_other.m_container;
+  }
+  size_t size() const { return m_container->size(); }
+  GameObjectSmartPtr<T> front() const { return m_container->front(); }
+  GameObjectSmartPtr<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.
 //
@@ -369,7 +444,7 @@ class GameStrategyRep : public GameObject {
 };
 
 /// A player in a game
-class GamePlayerRep : public GameObject {
+class GamePlayerRep : public std::enable_shared_from_this<GamePlayerRep> {
   friend class GameRep;
   friend class GameExplicitRep;
   friend class GameTreeRep;
@@ -388,20 +463,24 @@ class GamePlayerRep : public GameObject {
   void MakeReducedStrats(class GameNodeRep *, class GameNodeRep *);
   //@}
 
+  bool m_valid{true};
   GameRep *m_game;
   int m_number;
   std::string m_label;
   std::vector<GameInfosetRep *> m_infosets;
   std::vector<GameStrategyRep *> m_strategies;
 
-  GamePlayerRep(GameRep *p_game, int p_id) : m_game(p_game), m_number(p_id) {}
-  GamePlayerRep(GameRep *p_game, int p_id, int m_strats);
-  ~GamePlayerRep() override;
-
 public:
   using Infosets = ElementCollection<GamePlayer, GameInfosetRep>;
   using Strategies = ElementCollection<GamePlayer, GameStrategyRep>;
 
+  GamePlayerRep(GameRep *p_game, int p_id) : m_game(p_game), m_number(p_id) {}
+  GamePlayerRep(GameRep *p_game, int p_id, int m_strats);
+  ~GamePlayerRep();
+
+  bool IsValid() const { return m_valid; }
+  void Invalidate() { m_valid = false; }
+
   int GetNumber() const { return m_number; }
   Game GetGame() const;
 
@@ -415,7 +494,10 @@ class GamePlayerRep : public GameObject {
   /// Returns the p_index'th information set
   GameInfoset GetInfoset(int p_index) const { return m_infosets.at(p_index - 1); }
   /// Returns the information sets for the player
-  Infosets GetInfosets() const { return Infosets(this, &m_infosets); }
+  Infosets GetInfosets() const
+  {
+    return Infosets(std::const_pointer_cast<GamePlayerRep>(shared_from_this()), &m_infosets);
+  }
 
   /// @name Strategies
   //@{
@@ -499,7 +581,7 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   template <class T> friend class TableMixedStrategyProfileRep;
 
 protected:
-  std::vector<GamePlayerRep *> m_players;
+  std::vector<std::shared_ptr<GamePlayerRep>> m_players;
   std::vector<GameOutcomeRep *> m_outcomes;
   std::string m_title, m_comment;
   unsigned int m_version{0};
@@ -513,7 +595,7 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   //@}
 
 public:
-  using Players = ElementCollection<Game, GamePlayerRep>;
+  using Players = SmartElementCollection<Game, GamePlayerRep>;
   using Outcomes = ElementCollection<Game, GameOutcomeRep>;
 
   class Nodes {
@@ -728,17 +810,19 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   int NumStrategyContingencies() const
   {
     BuildComputedValues();
-    return std::transform_reduce(m_players.begin(), m_players.end(), 0, std::multiplies<>(),
-                                 [](const GamePlayerRep *p) { return p->m_strategies.size(); });
+    return std::transform_reduce(
+        m_players.begin(), m_players.end(), 0, std::multiplies<>(),
+        [](const std::shared_ptr<GamePlayerRep> &p) { return p->m_strategies.size(); });
   }
   /// Returns the total number of actions in the game
   virtual int BehavProfileLength() const = 0;
   /// Returns the total number of strategies in the game
   int MixedProfileLength() const
   {
     BuildComputedValues();
-    return std::transform_reduce(m_players.begin(), m_players.end(), 0, std::plus<>(),
-                                 [](const GamePlayerRep *p) { return p->m_strategies.size(); });
+    return std::transform_reduce(
+        m_players.begin(), m_players.end(), 0, std::plus<>(),
+        [](const std::shared_ptr<GamePlayerRep> &p) { return p->m_strategies.size(); });
   }
   //@}
 
@@ -778,7 +862,7 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   /// Returns the number of players in the game
   size_t NumPlayers() const { return m_players.size(); }
   /// Returns the pl'th player in the game
-  GamePlayer GetPlayer(int pl) const { return m_players.at(pl - 1); }
+  GamePlayer GetPlayer(int pl) const { return m_players.at(pl - 1)->shared_from_this(); }
   /// Returns the set of players in the game
   Players GetPlayers() const
   {
@@ -847,7 +931,7 @@ inline Game GameOutcomeRep::GetGame() const { return m_game->shared_from_this();
 template <class T> const T &GameOutcomeRep::GetPayoff(const GamePlayer &p_player) const
 {
   try {
-    return static_cast<const T &>(m_payoffs.at(p_player));
+    return static_cast<const T &>(m_payoffs.at(p_player.get()));
   }
   catch (const std::out_of_range &) {
     throw MismatchException();
@@ -857,7 +941,7 @@ template <class T> const T &GameOutcomeRep::GetPayoff(const GamePlayer &p_player
 template <> inline const Number &GameOutcomeRep::GetPayoff(const GamePlayer &p_player) const
 {
   try {
-    return m_payoffs.at(p_player);
+    return m_payoffs.at(p_player.get());
   }
   catch (const std::out_of_range &) {
     throw MismatchException();
@@ -869,14 +953,14 @@ inline void GameOutcomeRep::SetPayoff(const GamePlayer &p_player, const Number &
   if (p_player->GetGame() != GetGame()) {
     throw MismatchException();
   }
-  m_payoffs[p_player] = p_value;
+  m_payoffs[p_player.get()] = p_value;
   m_game->IncrementVersion();
 }
 
-inline GamePlayer GameStrategyRep::GetPlayer() const { return m_player; }
+inline GamePlayer GameStrategyRep::GetPlayer() const { return m_player->shared_from_this(); }
 
 inline Game GameInfosetRep::GetGame() const { return m_game->shared_from_this(); }
-inline GamePlayer GameInfosetRep::GetPlayer() const { return m_player; }
+inline GamePlayer GameInfosetRep::GetPlayer() const { return m_player->shared_from_this(); }
 inline bool GameInfosetRep::IsChanceInfoset() const { return m_player->IsChance(); }
 
 inline Game GamePlayerRep::GetGame() const { return m_game->shared_from_this(); }
@@ -888,7 +972,7 @@ inline GameStrategy GamePlayerRep::GetStrategy(int st) const
 inline GamePlayerRep::Strategies GamePlayerRep::GetStrategies() const
 {
   m_game->BuildComputedValues();
-  return Strategies(this, &m_strategies);
+  return Strategies(std::const_pointer_cast<GamePlayerRep>(shared_from_this()), &m_strategies);
 }
 
 inline Game GameNodeRep::GetGame() const { return m_game->shared_from_this(); }

src/games/gameagg.cc

@@ -136,8 +136,8 @@ template <class T>
 T AGGMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, const GameStrategy &ps1,
                                                 const GameStrategy &ps2) const
 {
-  GamePlayerRep *player1 = ps1->GetPlayer();
-  GamePlayerRep *player2 = ps2->GetPlayer();
+  const auto player1 = ps1->GetPlayer().get();
+  const auto player2 = ps2->GetPlayer().get();
   if (player1 == player2) {
     return (T)0;
   }
@@ -179,7 +179,7 @@ template class AGGMixedStrategyProfileRep<Rational>;
 GameAGGRep::GameAGGRep(std::shared_ptr<agg::AGG> p_aggPtr) : aggPtr(p_aggPtr)
 {
   for (int pl = 1; pl <= aggPtr->getNumPlayers(); pl++) {
-    m_players.push_back(new GamePlayerRep(this, pl, aggPtr->getNumActions(pl - 1)));
+    m_players.push_back(std::make_shared<GamePlayerRep>(this, pl, aggPtr->getNumActions(pl - 1)));
     m_players.back()->m_label = lexical_cast<std::string>(pl);
     std::for_each(m_players.back()->m_strategies.begin(), m_players.back()->m_strategies.end(),
                   [st = 1](GameStrategyRep *s) mutable { s->SetLabel(std::to_string(st++)); });

src/games/gamebagg.cc

@@ -156,8 +156,8 @@ template <class T>
 T BAGGMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, const GameStrategy &ps1,
                                                  const GameStrategy &ps2) const
 {
-  GamePlayerRep *player1 = ps1->GetPlayer();
-  GamePlayerRep *player2 = ps2->GetPlayer();
+  const auto player1 = ps1->GetPlayer().get();
+  const auto player2 = ps2->GetPlayer().get();
   if (player1 == player2) {
     return (T)0;
   }
@@ -212,7 +212,8 @@ GameBAGGRep::GameBAGGRep(std::shared_ptr<agg::BAGG> _baggPtr)
   int k = 1;
   for (int pl = 1; pl <= baggPtr->getNumPlayers(); pl++) {
     for (int j = 0; j < baggPtr->getNumTypes(pl - 1); j++, k++) {
-      m_players.push_back(new GamePlayerRep(this, k, baggPtr->getNumActions(pl - 1, j)));
+      m_players.push_back(
+          std::make_shared<GamePlayerRep>(this, k, baggPtr->getNumActions(pl - 1, j)));
       m_players.back()->m_label = std::to_string(k);
       agent2baggPlayer[k] = pl;
       std::for_each(m_players.back()->m_strategies.begin(), m_players.back()->m_strategies.end(),

src/games/gameobject.h

@@ -23,6 +23,8 @@
 #ifndef GAMBIT_GAMES_GAMEOBJECT_H
 #define GAMBIT_GAMES_GAMEOBJECT_H
 
+#include <memory>
+
 namespace Gambit {
 
 /// This is a base class for all game-related objects.  Primary among
@@ -161,6 +163,53 @@ template <class T> class GameObjectPtr {
   bool operator!() const { return !rep; }
 };
 
+template <class T> class GameObjectSmartPtr {
+private:
+  std::shared_ptr<T> m_rep;
+
+public:
+  GameObjectSmartPtr() = default;
+  GameObjectSmartPtr(std::nullptr_t r) : m_rep(r) {}
+  GameObjectSmartPtr(std::shared_ptr<T> r) : m_rep(r) {}
+  GameObjectSmartPtr(const GameObjectSmartPtr<T> &) = default;
+  ~GameObjectSmartPtr() = default;
+
+  GameObjectSmartPtr<T> &operator=(const GameObjectSmartPtr<T> &) = default;
+
+  std::shared_ptr<T> operator->() const
+  {
+    if (!m_rep) {
+      throw NullException();
+    }
+    if (!m_rep->IsValid()) {
+      throw InvalidObjectException();
+    }
+    return m_rep;
+  }
+  T *get() const
+  {
+    if (!m_rep) {
+      throw NullException();
+    }
+    if (!m_rep->IsValid()) {
+      throw InvalidObjectException();
+    }
+    return m_rep.get();
+  }
+
+  bool operator==(const GameObjectSmartPtr<T> &r) const { return (m_rep == r.m_rep); }
+  bool operator==(const std::shared_ptr<T> r) const { return (m_rep == r); }
+  bool operator==(const std::shared_ptr<const T> r) const { return (m_rep == r); }
+  bool operator==(const std::nullptr_t) const { return !bool(m_rep); }
+  bool operator!=(const GameObjectSmartPtr<T> &r) const { return (m_rep != r.m_rep); }
+  bool operator!=(const std::shared_ptr<T> r) const { return (m_rep != r); }
+  bool operator!=(const std::shared_ptr<const T> r) const { return (m_rep != r); }
+  bool operator!=(const std::nullptr_t) const { return bool(m_rep); }
+  bool operator<(const GameObjectSmartPtr<T> &r) const { return (m_rep < r.m_rep); }
+
+  operator bool() const noexcept { return bool(m_rep); }
+  operator std::shared_ptr<T>() const { return m_rep; }
+};
 } // end namespace Gambit
 
 #endif // GAMBIT_GAMES_GAMEOBJECT_H