Revert unrelated changes.

Author: tturocy

.github/workflows/python.yml

@@ -107,4 +107,4 @@ jobs:
         run: |
           python -m pip install -v .
       - name: Run tests
-        run: pytest -vv
+        run: pytest

src/games/gameobject.h

@@ -135,7 +135,7 @@ template <class T> class GameObjectPtr {
   bool operator<(const GameObjectPtr<T> &r) const { return (m_rep < r.m_rep); }
 
   operator bool() const noexcept { return m_rep != nullptr; }
-  operator std::shared_ptr<T>() const { return get_shared(); }
+  operator std::shared_ptr<T>() const { return m_rep; }
 };
 
 template <class P, class T> class ElementCollection {

src/games/gametable.cc

@@ -21,7 +21,6 @@
 //
 
 #include <iostream>
-#include <memory>
 
 #include "gambit.h"
 #include "gametable.h"
@@ -67,7 +66,7 @@ std::shared_ptr<PureStrategyProfileRep> TablePureStrategyProfileRep::Copy() cons
 
 Game NewTable(const std::vector<int> &p_dim, bool p_sparseOutcomes /*= false*/)
 {
-  return GameTableRep::Create(p_dim, p_sparseOutcomes);
+  return std::make_shared<GameTableRep>(p_dim, p_sparseOutcomes);
 }
 
 //------------------------------------------------------------------------
@@ -264,10 +263,6 @@ template class TableMixedStrategyProfileRep<Rational>;
 
 GameTableRep::GameTableRep(const std::vector<int> &dim, bool p_sparseOutcomes /* = false */)
   : m_results(std::accumulate(dim.begin(), dim.end(), 1, std::multiplies<>()))
-{
-}
-
-void GameTableRep::Initialize(const std::vector<int> &dim, bool p_sparseOutcomes /* = false */)
 {
   for (const auto &nstrat : dim) {
     m_players.push_back(std::make_shared<GamePlayerRep>(this, m_players.size() + 1, nstrat));
@@ -292,15 +287,6 @@ void GameTableRep::Initialize(const std::vector<int> &dim, bool p_sparseOutcomes
   }
 }
 
-std::shared_ptr<GameTableRep> GameTableRep::Create(const std::vector<int> &dim,
-                                                   bool sparseOutcomes)
-{
-  auto rep = std::shared_ptr<GameTableRep>(new GameTableRep(dim, sparseOutcomes));
-  rep->Initialize(dim, sparseOutcomes);
-
-  return rep;
-}
-
 Game GameTableRep::Copy() const
 {
   std::ostringstream os;

src/games/gametable.h

@@ -44,16 +44,12 @@ class GameTableRep : public GameExplicitRep {
   void RebuildTable();
   //@}
 
-  explicit GameTableRep(const std::vector<int> &p_dim, bool p_sparseOutcomes = false);
-  void Initialize(const std::vector<int> &dim, bool p_sparseOutcomes);
-
 public:
   /// @name Lifecycle
   //@{
   /// Construct a new table game with the given dimension
   /// If p_sparseOutcomes = true, outcomes for all contingencies are left null
-  static std::shared_ptr<GameTableRep> Create(const std::vector<int> &dim,
-                                              bool sparseOutcomes = false);
+  explicit GameTableRep(const std::vector<int> &p_dim, bool p_sparseOutcomes = false);
   Game Copy() const override;
   //@}
 

src/games/gametree.cc

@@ -701,28 +701,10 @@ GameInfoset GameTreeRep::InsertMove(GameNode p_node, GameInfoset p_infoset)
 //                        GameTreeRep: Lifecycle
 //------------------------------------------------------------------------
 
-GameTreeRep::GameTreeRep() = default;
-
-void GameTreeRep::Initialize()
-{
-  auto self = shared_from_this();
-
-  // Now construct children using the VALID GameTreeRep*
-  m_root = std::make_shared<GameNodeRep>(self.get(), nullptr);
-  m_chance = std::make_shared<GamePlayerRep>(self.get(), 0);
-
-  // If GameNodeRep creates children of its own, same pattern applies
-}
-
-std::shared_ptr<GameTreeRep> GameTreeRep::Create()
+GameTreeRep::GameTreeRep()
+  : m_root(std::make_shared<GameNodeRep>(this, nullptr)),
+    m_chance(std::make_shared<GamePlayerRep>(this, 0))
 {
-  // Construct object under shared_ptr CONTROL BLOCK
-  auto rep = std::shared_ptr<GameTreeRep>(new GameTreeRep());
-
-  // Now safe to construct children because shared_from_this works
-  rep->Initialize();
-
-  return rep;
 }
 
 GameTreeRep::~GameTreeRep()
@@ -739,7 +721,7 @@ Game GameTreeRep::Copy() const
   return ReadGame(is);
 }
 
-Game NewTree() { return GameTreeRep::Create(); }
+Game NewTree() { return std::make_shared<GameTreeRep>(); }
 
 //------------------------------------------------------------------------
 //                 GameTreeRep: General data access

src/games/gametree.h

@@ -68,14 +68,10 @@ class GameTreeRep : public GameExplicitRep {
   void CopySubtree(GameNodeRep *, GameNodeRep *, GameNodeRep *);
   //@}
 
-  GameTreeRep();
-  void Initialize();
-
 public:
   /// @name Lifecycle
   //@{
-
-  static std::shared_ptr<GameTreeRep> Create();
+  GameTreeRep();
   ~GameTreeRep() override;
   Game Copy() const override;
   //@}