Replace bespoke Game reference-counting with std::shared_ptr.

This removes the legacy reference-counting system for tracking references
to games with one based on std::shared_ptr.

Author: tturocy

src/games/behavmixed.cc

@@ -142,7 +142,7 @@ MixedBehaviorProfile<T>::MixedBehaviorProfile(const MixedStrategyProfile<T> &p_p
   GameNodeRep *root = m_support.GetGame()->GetRoot();
 
   const StrategySupportProfile &support = p_profile.GetSupport();
-  GameRep *game = m_support.GetGame();
+  GameRep *game = m_support.GetGame().get();
 
   for (auto player : game->GetPlayers()) {
     std::map<GameNode, T> map_nvals, map_bvals;

src/games/game.h

@@ -54,7 +54,7 @@ class GameNodeRep;
 using GameNode = GameObjectPtr<GameNodeRep>;
 
 class GameRep;
-using Game = GameObjectPtr<GameRep>;
+using Game = std::shared_ptr<GameRep>;
 
 template <class P, class T> class ElementCollection {
   P m_owner{nullptr};
@@ -488,7 +488,7 @@ class GameNodeRep : public GameObject {
 };
 
 /// This is the class for representing an arbitrary finite game.
-class GameRep : public BaseGameRep {
+class GameRep : public std::enable_shared_from_this<GameRep> {
   friend class GameOutcomeRep;
   friend class GameNodeRep;
   friend class PureStrategyProfileRep;
@@ -536,7 +536,8 @@ class GameRep : public BaseGameRep {
 
       iterator() = default;
 
-      iterator(const Game &game, const GameNode &start_node) : m_owner(game), m_current_node(start_node)
+      iterator(const Game &game, const GameNode &start_node)
+        : m_owner(game), m_current_node(start_node)
       {
         if (!start_node) {
           return;
@@ -600,7 +601,7 @@ class GameRep : public BaseGameRep {
   /// @name Lifecycle
   //@{
   /// Clean up the game
-  ~GameRep() override;
+  virtual ~GameRep();
 
   /// Create a copy of the game, as a new game
   virtual Game Copy() const = 0;
@@ -778,7 +779,10 @@ class GameRep : public BaseGameRep {
   /// Returns the pl'th player in the game
   GamePlayer GetPlayer(int pl) const { return m_players.at(pl - 1); }
   /// Returns the set of players in the game
-  Players GetPlayers() const { return Players(this, &m_players); }
+  Players GetPlayers() const
+  {
+    return Players(std::const_pointer_cast<GameRep>(shared_from_this()), &m_players);
+  }
   /// Returns the chance (nature) player
   virtual GamePlayer GetChance() const = 0;
   /// Creates a new player in the game, with no moves
@@ -798,7 +802,10 @@ class GameRep : public BaseGameRep {
   /// Returns the index'th outcome defined in the game
   GameOutcome GetOutcome(int index) const { return m_outcomes.at(index - 1); }
   /// Returns the set of outcomes in the game
-  Outcomes GetOutcomes() const { return Outcomes(this, &m_outcomes); }
+  Outcomes GetOutcomes() const
+  {
+    return Outcomes(std::const_pointer_cast<GameRep>(shared_from_this()), &m_outcomes);
+  }
   /// Creates a new outcome in the game
   virtual GameOutcome NewOutcome() { throw UndefinedException(); }
   /// Deletes the specified outcome from the game
@@ -810,7 +817,7 @@ class GameRep : public BaseGameRep {
   /// Returns the root node of the game
   virtual GameNode GetRoot() const = 0;
   /// Returns a range that can be used to iterate over the nodes of the game
-  Nodes GetNodes() const { return Nodes(this); }
+  Nodes GetNodes() const { return Nodes(std::const_pointer_cast<GameRep>(shared_from_this())); }
   /// Returns the number of nodes in the game
   virtual size_t NumNodes() const = 0;
   /// Returns the number of non-terminal nodes in the game
@@ -834,7 +841,7 @@ class GameRep : public BaseGameRep {
 // These must be postponed to here in the file because they require
 // all classes to be defined.
 
-inline Game GameOutcomeRep::GetGame() const { return m_game; }
+inline Game GameOutcomeRep::GetGame() const { return m_game->shared_from_this(); }
 
 template <class T> const T &GameOutcomeRep::GetPayoff(const GamePlayer &p_player) const
 {
@@ -867,11 +874,11 @@ inline void GameOutcomeRep::SetPayoff(const GamePlayer &p_player, const Number &
 
 inline GamePlayer GameStrategyRep::GetPlayer() const { return m_player; }
 
-inline Game GameInfosetRep::GetGame() const { return m_game; }
+inline Game GameInfosetRep::GetGame() const { return m_game->shared_from_this(); }
 inline GamePlayer GameInfosetRep::GetPlayer() const { return m_player; }
 inline bool GameInfosetRep::IsChanceInfoset() const { return m_player->IsChance(); }
 
-inline Game GamePlayerRep::GetGame() const { return m_game; }
+inline Game GamePlayerRep::GetGame() const { return m_game->shared_from_this(); }
 inline GameStrategy GamePlayerRep::GetStrategy(int st) const
 {
   m_game->BuildComputedValues();
@@ -883,7 +890,7 @@ inline GamePlayerRep::Strategies GamePlayerRep::GetStrategies() const
   return Strategies(this, &m_strategies);
 }
 
-inline Game GameNodeRep::GetGame() const { return m_game; }
+inline Game GameNodeRep::GetGame() const { return m_game->shared_from_this(); }
 
 //=======================================================================
 

src/games/gameagg.cc

@@ -226,20 +226,20 @@ GameStrategy GameAGGRep::GetStrategy(int p_index) const
 
 PureStrategyProfile GameAGGRep::NewPureStrategyProfile() const
 {
-  return PureStrategyProfile(
-      std::make_shared<AGGPureStrategyProfileRep>(const_cast<GameAGGRep *>(this)));
+  return PureStrategyProfile(std::make_shared<AGGPureStrategyProfileRep>(
+      std::const_pointer_cast<GameRep>(shared_from_this())));
 }
 
 MixedStrategyProfile<double> GameAGGRep::NewMixedStrategyProfile(double) const
 {
   return MixedStrategyProfile<double>(new AGGMixedStrategyProfileRep<double>(
-      StrategySupportProfile(const_cast<GameAGGRep *>(this))));
+      StrategySupportProfile(std::const_pointer_cast<GameRep>(shared_from_this()))));
 }
 
 MixedStrategyProfile<Rational> GameAGGRep::NewMixedStrategyProfile(const Rational &) const
 {
   return MixedStrategyProfile<Rational>(new AGGMixedStrategyProfileRep<Rational>(
-      StrategySupportProfile(const_cast<GameAGGRep *>(this))));
+      StrategySupportProfile(std::const_pointer_cast<GameRep>(shared_from_this()))));
 }
 MixedStrategyProfile<double>
 GameAGGRep::NewMixedStrategyProfile(double, const StrategySupportProfile &spt) const
@@ -265,7 +265,7 @@ bool GameAGGRep::IsConstSum() const
     sum += profile->GetPayoff(player);
   }
 
-  for (auto iter : StrategyContingencies(Game(this))) {
+  for (auto iter : StrategyContingencies(std::const_pointer_cast<GameRep>(shared_from_this()))) {
     Rational newsum(0);
     for (const auto &player : m_players) {
       newsum += iter->GetPayoff(player);

src/games/gameagg.h

@@ -120,7 +120,7 @@ class GameAGGRep : public GameRep {
 inline Game ReadAggFile(std::istream &p_stream)
 {
   try {
-    return new GameAGGRep(agg::AGG::makeAGG(p_stream));
+    return std::make_shared<GameAGGRep>(agg::AGG::makeAGG(p_stream));
   }
   catch (std::runtime_error &ex) {
     throw InvalidFileException(ex.what());

src/games/gamebagg.cc

@@ -244,20 +244,20 @@ Array<int> GameBAGGRep::NumStrategies() const
 
 PureStrategyProfile GameBAGGRep::NewPureStrategyProfile() const
 {
-  return PureStrategyProfile(
-      std::make_shared<BAGGPureStrategyProfileRep>(const_cast<GameBAGGRep *>(this)));
+  return PureStrategyProfile(std::make_shared<BAGGPureStrategyProfileRep>(
+      std::const_pointer_cast<GameRep>(shared_from_this())));
 }
 
 MixedStrategyProfile<double> GameBAGGRep::NewMixedStrategyProfile(double) const
 {
   return MixedStrategyProfile<double>(new BAGGMixedStrategyProfileRep<double>(
-      StrategySupportProfile(const_cast<GameBAGGRep *>(this))));
+      StrategySupportProfile(std::const_pointer_cast<GameRep>(shared_from_this()))));
 }
 
 MixedStrategyProfile<Rational> GameBAGGRep::NewMixedStrategyProfile(const Rational &) const
 {
   return MixedStrategyProfile<Rational>(new BAGGMixedStrategyProfileRep<Rational>(
-      StrategySupportProfile(const_cast<GameBAGGRep *>(this))));
+      StrategySupportProfile(std::const_pointer_cast<GameRep>(shared_from_this()))));
 }
 MixedStrategyProfile<double>
 GameBAGGRep::NewMixedStrategyProfile(double, const StrategySupportProfile &spt) const

src/games/gamebagg.h

@@ -128,7 +128,7 @@ class GameBAGGRep : public GameRep {
 inline Game ReadBaggFile(std::istream &in)
 {
   try {
-    return new GameBAGGRep(agg::BAGG::makeBAGG(in));
+    return std::make_shared<GameBAGGRep>(agg::BAGG::makeBAGG(in));
   }
   catch (std::runtime_error &ex) {
     throw InvalidFileException(ex.what());

src/games/gameobject.h

@@ -84,52 +84,6 @@ class GameObject {
   //@}
 };
 
-class BaseGameRep {
-protected:
-  int m_refCount{0};
-
-public:
-  /// @name Lifecycle
-  //@{
-  /// Constructor
-  BaseGameRep() = default;
-
-  /// Destructor
-  virtual ~BaseGameRep() = default;
-  //@}
-
-  /// @name Validation
-  //@{
-  /// Is the object still valid?
-  bool IsValid() const { return true; }
-
-  /// Invalidate the object; delete if not referenced elsewhere
-  void Invalidate()
-  {
-    if (!m_refCount) {
-      delete this;
-    }
-  }
-  //@}
-
-  /// @name Reference counting
-  //@{
-  /// Increment the reference count
-  void IncRef() { m_refCount++; }
-
-  /// Decrement the reference count; delete if reference count is zero.
-  void DecRef()
-  {
-    if (!--m_refCount) {
-      delete this;
-    }
-  }
-
-  /// Returns the reference count
-  int RefCount() const { return m_refCount; }
-  //@}
-};
-
 /// An exception thrown when attempting to dereference an invalidated object
 class InvalidObjectException : public Exception {
 public:

src/games/gametable.cc

@@ -66,7 +66,7 @@ std::shared_ptr<PureStrategyProfileRep> TablePureStrategyProfileRep::Copy() cons
 
 Game NewTable(const std::vector<int> &p_dim, bool p_sparseOutcomes /*= false*/)
 {
-  return new GameTableRep(p_dim, p_sparseOutcomes);
+  return std::make_shared<GameTableRep>(p_dim, p_sparseOutcomes);
 }
 
 //------------------------------------------------------------------------
@@ -116,8 +116,8 @@ Rational TablePureStrategyProfileRep::GetStrategyValue(const GameStrategy &p_str
 
 PureStrategyProfile GameTableRep::NewPureStrategyProfile() const
 {
-  return PureStrategyProfile(
-      std::make_shared<TablePureStrategyProfileRep>(const_cast<GameTableRep *>(this)));
+  return PureStrategyProfile(std::make_shared<TablePureStrategyProfileRep>(
+      std::const_pointer_cast<GameRep>(shared_from_this())));
 }
 
 //========================================================================
@@ -308,7 +308,7 @@ bool GameTableRep::IsConstSum() const
     sum += profile->GetPayoff(player);
   }
 
-  for (auto iter : StrategyContingencies(Game(this))) {
+  for (auto iter : StrategyContingencies(std::const_pointer_cast<GameRep>(shared_from_this()))) {
     Rational newsum(0);
     for (const auto &player : m_players) {
       newsum += iter->GetPayoff(player);
@@ -401,7 +401,7 @@ void GameTableRep::DeleteOutcome(const GameOutcome &p_outcome)
 
 GameStrategy GameTableRep::NewStrategy(const GamePlayer &p_player, const std::string &p_label)
 {
-  if (p_player->GetGame() != this) {
+  if (p_player->GetGame().get() != this) {
     throw MismatchException();
   }
   IncrementVersion();
@@ -437,13 +437,13 @@ void GameTableRep::DeleteStrategy(const GameStrategy &p_strategy)
 
 MixedStrategyProfile<double> GameTableRep::NewMixedStrategyProfile(double) const
 {
-  return StrategySupportProfile(const_cast<GameTableRep *>(this))
+  return StrategySupportProfile(std::const_pointer_cast<GameRep>(shared_from_this()))
       .NewMixedStrategyProfile<double>();
 }
 
 MixedStrategyProfile<Rational> GameTableRep::NewMixedStrategyProfile(const Rational &) const
 {
-  return StrategySupportProfile(const_cast<GameTableRep *>(this))
+  return StrategySupportProfile(std::const_pointer_cast<GameRep>(shared_from_this()))
       .NewMixedStrategyProfile<Rational>();
 }
 
@@ -477,8 +477,8 @@ void GameTableRep::RebuildTable()
   std::vector<GameOutcomeRep *> newResults(size);
   std::fill(newResults.begin(), newResults.end(), nullptr);
 
-  for (auto iter :
-       StrategyContingencies(StrategySupportProfile(const_cast<GameTableRep *>(this)))) {
+  for (auto iter : StrategyContingencies(
+           StrategySupportProfile(std::const_pointer_cast<GameRep>(shared_from_this())))) {
     long newindex = 0L;
     for (const auto &player : m_players) {
       if (iter->GetStrategy(player)->m_offset < 0) {