Convert player to use shared pointers

Author: tturocy

src/games/game.cc

@@ -63,12 +63,13 @@ GameAction GameStrategyRep::GetAction(const GameInfoset &p_infoset) const
 //                       class GamePlayerRep
 //========================================================================
 
-GamePlayerRep::GamePlayerRep(GameRep *p_game, int p_id, int p_strats)
-  : m_game(p_game), m_number(p_id)
+std::shared_ptr<GamePlayerRep> GamePlayerRep::CreatePlayer(GameRep *p_game, int p_id, int p_strats)
 {
+  auto player = std::make_shared<GamePlayerRep>(p_game, p_id);
   for (int j = 1; j <= p_strats; j++) {
-    m_strategies.push_back(new GameStrategyRep(this, j, ""));
+    player->m_strategies.push_back(new GameStrategyRep(player, j, ""));
   }
+  return player;
 }
 
 GamePlayerRep::~GamePlayerRep()
@@ -94,7 +95,8 @@ void GamePlayerRep::MakeStrategy()
     }
   }
 
-  auto *strategy = new GameStrategyRep(this, m_strategies.size() + 1, "");
+  auto *strategy = new GameStrategyRep(std::const_pointer_cast<GamePlayerRep>(shared_from_this()),
+                                       m_strategies.size() + 1, "");
   strategy->m_behav = c;
 
   // We generate a default labeling -- probably should be changed in future
@@ -123,7 +125,7 @@ void GamePlayerRep::MakeReducedStrats(GameNodeRep *n, GameNodeRep *nn)
   }
 
   if (!n->IsTerminal()) {
-    if (n->m_infoset->m_player == this) {
+    if (n->m_infoset->m_player.get() == this) {
       if (n->m_infoset->flag == 0) {
         // we haven't visited this infoset before
         n->m_infoset->flag = 1;
@@ -367,7 +369,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>::get(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 = GameObjectSharedPtr<GamePlayerRep>;
 
 class GameNodeRep;
 using GameNode = GameObjectPtr<GameNodeRep>;
@@ -271,7 +271,7 @@ class GameOutcomeRep : public std::enable_shared_from_this<GameOutcomeRep> {
   GameRep *m_game;
   int m_number;
   std::string m_label;
-  std::map<GamePlayerRep *, Number> m_payoffs;
+  std::map<std::shared_ptr<GamePlayerRep>, Number> m_payoffs;
 
 public:
   /// @name Lifecycle
@@ -348,10 +348,10 @@ class GameInfosetRep : public std::enable_shared_from_this<GameInfosetRep> {
   template <class T> friend class MixedBehaviorProfile;
 
   bool m_valid{true};
-  GameRep *m_game;
-  int m_number;
+  GameRep *m_game{nullptr};
+  int m_number{0};
   std::string m_label;
-  GamePlayerRep *m_player;
+  std::shared_ptr<GamePlayerRep> m_player;
   std::vector<std::shared_ptr<GameActionRep>> m_actions;
   std::vector<GameNodeRep *> m_members;
   int flag{0}, whichbranch{0};
@@ -371,7 +371,8 @@ class GameInfosetRep : public std::enable_shared_from_this<GameInfosetRep> {
   ~GameInfosetRep();
 
   static std::shared_ptr<GameInfosetRep> CreateInfoset(GameRep *p_efg, int p_number,
-                                                       GamePlayerRep *p_player, int p_actions);
+                                                       std::shared_ptr<GamePlayerRep> p_player,
+                                                       int p_actions);
 
   /// @name Validity management
   //@{
@@ -441,7 +442,7 @@ class GameStrategyRep : public GameObject {
   template <class T> friend class TableMixedStrategyProfileRep;
   template <class T> friend class MixedBehaviorProfile;
 
-  GamePlayerRep *m_player;
+  std::shared_ptr<GamePlayerRep> m_player;
   int m_number;
   long m_offset{-1L};
   std::string m_label;
@@ -450,7 +451,8 @@ class GameStrategyRep : public GameObject {
   /// @name Lifecycle
   //@{
   /// Creates a new strategy for the given player.
-  explicit GameStrategyRep(GamePlayerRep *p_player, int p_number, const std::string &p_label)
+  explicit GameStrategyRep(std::shared_ptr<GamePlayerRep> p_player, int p_number,
+                           const std::string &p_label)
     : m_player(p_player), m_number(p_number), m_label(p_label)
   {
   }
@@ -475,7 +477,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;
@@ -494,20 +496,27 @@ 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<std::shared_ptr<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 = SmartElementCollection<GamePlayer, GameInfosetRep>;
   using Strategies = ElementCollection<GamePlayer, GameStrategyRep>;
 
+  GamePlayerRep(GameRep *p_game, int p_id) : m_game(p_game), m_number(p_id) {}
+  static std::shared_ptr<GamePlayerRep> CreatePlayer(GameRep *p_game, int p_id, int p_strats);
+  ~GamePlayerRep();
+
+  /// @name Validity management
+  //@{
+  bool IsValid() const { return m_valid; }
+  void Invalidate() { m_valid = false; }
+  //@}
+
   int GetNumber() const { return m_number; }
   Game GetGame() const;
 
@@ -521,7 +530,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
   //@{
@@ -605,7 +617,7 @@ class GameRep : public BaseGameRep {
   template <class T> friend class TableMixedStrategyProfileRep;
 
 protected:
-  std::vector<GamePlayerRep *> m_players;
+  std::vector<std::shared_ptr<GamePlayerRep>> m_players;
   std::vector<std::shared_ptr<GameOutcomeRep>> m_outcomes;
   std::string m_title, m_comment;
   unsigned int m_version{0};
@@ -619,7 +631,7 @@ class GameRep : public BaseGameRep {
   //@}
 
 public:
-  using Players = ElementCollection<Game, GamePlayerRep>;
+  using Players = SmartElementCollection<Game, GamePlayerRep>;
   using Outcomes = SmartElementCollection<Game, GameOutcomeRep>;
 
   class Nodes {
@@ -834,17 +846,19 @@ class GameRep : public BaseGameRep {
   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(); });
   }
   //@}
 
@@ -988,7 +1002,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; }

src/games/gameagg.cc

@@ -136,10 +136,10 @@ 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 std::shared_ptr<GamePlayerRep> player1 = ps1->GetPlayer();
+  const std::shared_ptr<GamePlayerRep> player2 = ps2->GetPlayer();
   if (player1 == player2) {
-    return (T)0;
+    return static_cast<T>(0);
   }
 
   auto &g = dynamic_cast<GameAGGRep &>(*(this->m_support.GetGame()));
@@ -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(GamePlayerRep::CreatePlayer(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,10 +156,10 @@ 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 std::shared_ptr<GamePlayerRep> player1 = ps1->GetPlayer();
+  const std::shared_ptr<GamePlayerRep> player2 = ps2->GetPlayer();
   if (player1 == player2) {
-    return (T)0;
+    return static_cast<T>(0);
   }
 
   auto &g = dynamic_cast<GameBAGGRep &>(*(this->m_support.GetGame()));
@@ -212,7 +212,7 @@ 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(GamePlayerRep::CreatePlayer(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/gametable.cc

@@ -86,7 +86,8 @@ GameOutcome TablePureStrategyProfileRep::GetOutcome() const
 
 void TablePureStrategyProfileRep::SetOutcome(GameOutcome p_outcome)
 {
-  dynamic_cast<GameTableRep &>(*m_nfg).m_results[m_index] = std::shared_ptr<GameOutcomeRep>(p_outcome);
+  dynamic_cast<GameTableRep &>(*m_nfg).m_results[m_index] =
+      std::shared_ptr<GameOutcomeRep>(p_outcome);
 }
 
 Rational TablePureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) const
@@ -103,9 +104,8 @@ Rational TablePureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) cons
 Rational TablePureStrategyProfileRep::GetStrategyValue(const GameStrategy &p_strategy) const
 {
   const auto &player = p_strategy->GetPlayer();
-  auto outcome =
-      dynamic_cast<GameTableRep &>(*m_nfg)
-          .m_results[m_index - m_profile.at(player)->m_offset + p_strategy->m_offset];
+  auto outcome = dynamic_cast<GameTableRep &>(*m_nfg)
+                     .m_results[m_index - m_profile.at(player)->m_offset + p_strategy->m_offset];
   if (outcome) {
     return outcome->GetPayoff<Rational>(player);
   }
@@ -246,8 +246,8 @@ template <class T>
 T TableMixedStrategyProfileRep<T>::GetPayoffDeriv(int pl, const GameStrategy &strategy1,
                                                   const GameStrategy &strategy2) const
 {
-  GamePlayerRep *player1 = strategy1->GetPlayer();
-  GamePlayerRep *player2 = strategy2->GetPlayer();
+  auto player1 = strategy1->GetPlayer();
+  auto player2 = strategy2->GetPlayer();
   if (player1 == player2) {
     return T(0);
   }
@@ -269,7 +269,7 @@ GameTableRep::GameTableRep(const std::vector<int> &dim, bool p_sparseOutcomes /*
   : m_results(std::accumulate(dim.begin(), dim.end(), 1, std::multiplies<>()))
 {
   for (const auto &nstrat : dim) {
-    m_players.push_back(new GamePlayerRep(this, m_players.size() + 1, nstrat));
+    m_players.push_back(GamePlayerRep::CreatePlayer(this, m_players.size() + 1, nstrat));
     m_players.back()->m_label = lexical_cast<std::string>(m_players.size());
     std::for_each(
         m_players.back()->m_strategies.begin(), m_players.back()->m_strategies.end(),
@@ -279,8 +279,9 @@ GameTableRep::GameTableRep(const std::vector<int> &dim, bool p_sparseOutcomes /*
 
   if (!p_sparseOutcomes) {
     m_outcomes = std::vector<std::shared_ptr<GameOutcomeRep>>(m_results.size());
-    std::generate(m_outcomes.begin(), m_outcomes.end(),
-                  [this, outc = 1]() mutable { return std::make_shared<GameOutcomeRep>(this, outc++); });
+    std::generate(m_outcomes.begin(), m_outcomes.end(), [this, outc = 1]() mutable {
+      return std::make_shared<GameOutcomeRep>(this, outc++);
+    });
     std::copy(m_outcomes.begin(), m_outcomes.end(), m_results.begin());
   }
 }
@@ -370,7 +371,7 @@ void GameTableRep::WriteNfgFile(std::ostream &p_file) const
 GamePlayer GameTableRep::NewPlayer()
 {
   IncrementVersion();
-  auto player = new GamePlayerRep(this, m_players.size() + 1, 1);
+  auto player = GamePlayerRep::CreatePlayer(this, m_players.size() + 1, 1);
   m_players.push_back(player);
   for (auto outcome : m_outcomes) {
     outcome->m_payoffs[player] = Number();
@@ -385,9 +386,10 @@ GamePlayer GameTableRep::NewPlayer()
 void GameTableRep::DeleteOutcome(const GameOutcome &p_outcome)
 {
   IncrementVersion();
-  std::replace(m_results.begin(), m_results.end(),
-    std::shared_ptr<GameOutcomeRep>(p_outcome), std::shared_ptr<GameOutcomeRep>());
-  m_outcomes.erase(std::find(m_outcomes.begin(), m_outcomes.end(), std::shared_ptr<GameOutcomeRep>(p_outcome)));
+  std::replace(m_results.begin(), m_results.end(), std::shared_ptr<GameOutcomeRep>(p_outcome),
+               std::shared_ptr<GameOutcomeRep>());
+  m_outcomes.erase(
+      std::find(m_outcomes.begin(), m_outcomes.end(), std::shared_ptr<GameOutcomeRep>(p_outcome)));
   p_outcome->Invalidate();
   std::for_each(m_outcomes.begin(), m_outcomes.end(),
                 [outc = 1](std::shared_ptr<GameOutcomeRep> c) mutable { c->m_number = outc++; });
@@ -411,7 +413,7 @@ GameStrategy GameTableRep::NewStrategy(const GamePlayer &p_player, const std::st
 
 void GameTableRep::DeleteStrategy(const GameStrategy &p_strategy)
 {
-  GamePlayerRep *player = p_strategy->GetPlayer();
+  auto player = p_strategy->GetPlayer();
   if (player->m_game != this) {
     throw MismatchException();
   }

src/games/gametree.cc

@@ -152,7 +152,8 @@ GameInfoset GameActionRep::GetInfoset() const { return m_infoset.lock(); }
 //========================================================================
 
 std::shared_ptr<GameInfosetRep>
-GameInfosetRep::CreateInfoset(GameRep *p_efg, int p_number, GamePlayerRep *p_player, int p_actions)
+GameInfosetRep::CreateInfoset(GameRep *p_efg, int p_number,
+                              std::shared_ptr<GamePlayerRep> p_player, int p_actions)
 {
   auto infoset = std::make_shared<GameInfosetRep>();
   infoset->m_game = p_efg;
@@ -189,7 +190,7 @@ void GameTreeRep::SetPlayer(GameInfoset p_infoset, GamePlayer p_player)
     return;
   }
 
-  GamePlayerRep *oldPlayer = p_infoset->GetPlayer();
+  auto oldPlayer = p_infoset->GetPlayer();
   IncrementVersion();
   oldPlayer->m_infosets.erase(std::find(oldPlayer->m_infosets.begin(), oldPlayer->m_infosets.end(),
                                         std::shared_ptr<GameInfosetRep>(p_infoset)));
@@ -564,7 +565,7 @@ GameInfoset GameTreeRep::LeaveInfoset(GameNode p_node)
     return oldInfoset;
   }
 
-  GamePlayerRep *player = oldInfoset->m_player;
+  auto player = oldInfoset->m_player;
   RemoveMember(oldInfoset, node);
   node->m_infoset = GameInfosetRep::CreateInfoset(this, player->m_infosets.size() + 1, player,
                                                   node->m_children.size());
@@ -813,7 +814,7 @@ void GameTreeRep::Canonicalize()
   NumberNodes(m_root, nodeindex);
 
   for (size_t pl = 0; pl <= m_players.size(); pl++) {
-    GamePlayerRep *player = (pl) ? m_players[pl - 1] : m_chance;
+    auto player = (pl) ? m_players[pl - 1] : m_chance;
 
     // Sort nodes within information sets according to ID.
     // Coded using a bubble sort for simplicity; large games might
@@ -992,7 +993,7 @@ int GameTreeRep::BehavProfileLength() const
 GamePlayer GameTreeRep::NewPlayer()
 {
   IncrementVersion();
-  auto player = new GamePlayerRep(this, m_players.size() + 1);
+  auto player = std::make_shared<GamePlayerRep>(this, m_players.size() + 1);
   m_players.push_back(player);
   for (auto &outcome : m_outcomes) {
     outcome->m_payoffs[player] = Number();

src/games/gametree.h

@@ -35,7 +35,7 @@ class GameTreeRep : public GameExplicitRep {
 protected:
   mutable bool m_computedValues{false}, m_doCanon{true};
   GameNodeRep *m_root;
-  GamePlayerRep *m_chance;
+  std::shared_ptr<GamePlayerRep> m_chance;
   std::size_t m_numNodes = 1;
   std::size_t m_numNonterminalNodes = 0;
   std::map<GameNodeRep *, std::vector<GameNodeRep *>> m_nodePlays;