Some tidy recommendations

Author: tturocy

src/games/game.cc

@@ -74,7 +74,7 @@ Array<GameStrategy> GamePlayerRep::GetStrategies() const
   m_game->BuildComputedValues();
   Array<GameStrategy> ret(m_strategies.size());
   std::transform(m_strategies.cbegin(), m_strategies.cend(), ret.begin(),
-                 [](GameStrategyRep *s) -> GameStrategy { return s; });
+                 [](const GameStrategyRep *s) -> GameStrategy { return s; });
   return ret;
 }
 
@@ -113,7 +113,7 @@ void GamePlayerRep::MakeStrategy()
 
 void GamePlayerRep::MakeReducedStrats(GameNodeRep *n, GameNodeRep *nn)
 {
-  GameNodeRep *m, *mm;
+  GameNodeRep *m;
 
   if (!n->GetParent()) {
     n->ptr = nullptr;
@@ -162,7 +162,7 @@ void GamePlayerRep::MakeReducedStrats(GameNodeRep *n, GameNodeRep *nn)
       }
     }
     if (m) {
-      mm = m->m_parent->whichbranch;
+      GameNodeRep *mm = m->m_parent->whichbranch;
       m->m_parent->whichbranch = m;
       MakeReducedStrats(m, m);
       m->m_parent->whichbranch = mm;
@@ -182,7 +182,7 @@ Array<GameInfoset> GamePlayerRep::GetInfosets() const
 {
   Array<GameInfoset> ret(m_infosets.size());
   std::transform(m_infosets.cbegin(), m_infosets.cend(), ret.begin(),
-                 [](GameInfosetRep *s) -> GameInfoset { return s; });
+                 [](const GameInfosetRep *s) -> GameInfoset { return s; });
   return ret;
 }
 
@@ -193,7 +193,7 @@ size_t GamePlayerRep::NumSequences() const
   }
   return std::accumulate(
       m_infosets.cbegin(), m_infosets.cend(), 1,
-      [](int ct, GameInfosetRep *s) -> int { return ct + s->m_actions.size(); });
+      [](int ct, const GameInfosetRep *s) -> int { return ct + s->m_actions.size(); });
 }
 
 //========================================================================
@@ -302,11 +302,11 @@ template <class T> MixedStrategyProfileRep<T> *MixedStrategyProfileRep<T>::Norma
 {
   auto norm = Copy();
   for (auto player : m_support.GetGame()->GetPlayers()) {
-    T sum = (T)0;
+    T sum = static_cast<T>(0);
     for (auto strategy : m_support.GetStrategies(player)) {
       sum += (*this)[strategy];
     }
-    if (sum == (T)0) {
+    if (sum == static_cast<T>(0)) {
       continue;
     }
     for (auto strategy : m_support.GetStrategies(player)) {

src/games/game.h

@@ -381,7 +381,7 @@ class GameNodeRep : public GameObject {
   GameNodeRep *whichbranch{nullptr}, *ptr{nullptr};
 
   GameNodeRep(GameRep *e, GameNodeRep *p);
-  ~GameNodeRep();
+  ~GameNodeRep() override;
 
   void DeleteOutcome(GameOutcomeRep *outc);
 
@@ -750,7 +750,7 @@ template <class Generator>
 std::list<Rational> UniformOnSimplex(int p_denom, size_t p_dim, Generator &generator)
 {
   // NOLINTBEGIN(misc-const-correctness)
-  std::uniform_int_distribution dist(1, p_denom + int(p_dim) - 1);
+  std::uniform_int_distribution dist(1, p_denom + static_cast<int>(p_dim) - 1);
   // NOLINTEND(misc-const-correctness)
   std::set<int> cutoffs;
   while (cutoffs.size() < p_dim - 1) {

src/games/gameexpl.cc

@@ -119,16 +119,17 @@ GameStrategy GameExplicitRep::GetStrategy(int p_index) const
 int GameExplicitRep::NumStrategyContingencies() const
 {
   const_cast<GameExplicitRep *>(this)->BuildComputedValues();
-  return std::accumulate(m_players.begin(), m_players.end(), 1, [](int ncont, GamePlayerRep *p) {
-    return ncont * p->m_strategies.size();
-  });
+  return std::accumulate(
+      m_players.begin(), m_players.end(), 1,
+      [](int ncont, const GamePlayerRep *p) { return ncont * p->m_strategies.size(); });
 }
 
 int GameExplicitRep::MixedProfileLength() const
 {
   const_cast<GameExplicitRep *>(this)->BuildComputedValues();
-  return std::accumulate(m_players.begin(), m_players.end(), 0,
-                         [](int size, GamePlayerRep *p) { return size + p->m_strategies.size(); });
+  return std::accumulate(
+      m_players.begin(), m_players.end(), 0,
+      [](int size, const GamePlayerRep *p) { return size + p->m_strategies.size(); });
 }
 
 //------------------------------------------------------------------------

src/games/gametree.cc

@@ -297,7 +297,7 @@ Array<GameNode> GameInfosetRep::GetMembers() const
 {
   Array<GameNode> ret(m_members.size());
   std::transform(m_members.cbegin(), m_members.cend(), ret.begin(),
-                 [](GameNodeRep *n) -> GameNode { return n; });
+                 [](const GameNodeRep *n) -> GameNode { return n; });
   return ret;
 }
 
@@ -322,7 +322,7 @@ Array<GameNode> GameNodeRep::GetChildren() const
 {
   Array<GameNode> ret(m_children.size());
   std::transform(m_children.cbegin(), m_children.cend(), ret.begin(),
-                 [](GameNodeRep *n) -> GameNode { return n; });
+                 [](const GameNodeRep *n) -> GameNode { return n; });
   return ret;
 }
 
@@ -910,13 +910,13 @@ void WriteEfgFile(std::ostream &f, const GameNode &n)
     }
     f << n->GetInfoset()->GetNumber() << " " << QuoteString(n->GetInfoset()->GetLabel()) << ' ';
     if (n->GetInfoset()->IsChanceInfoset()) {
-      f << FormatList(n->GetInfoset()->GetActions(), [n](const GameAction &a) {
+      f << FormatList(n->GetInfoset()->GetActions(), [](const GameAction &a) {
         return QuoteString(a->GetLabel()) + " " + std::string(a->GetInfoset()->GetActionProb(a));
       });
     }
     else {
       f << FormatList(n->GetInfoset()->GetActions(),
-                      [n](const GameAction &a) { return QuoteString(a->GetLabel()); });
+                      [](const GameAction &a) { return QuoteString(a->GetLabel()); });
     }
     f << ' ';
   }
@@ -1188,8 +1188,7 @@ Rational TreePureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) const
   PureBehaviorProfile behav(m_nfg);
   for (const auto &player : m_nfg->GetPlayers()) {
     for (size_t iset = 1; iset <= player->NumInfosets(); iset++) {
-      const int act = m_profile.at(player)->m_behav[iset];
-      if (act) {
+      if (const int act = m_profile.at(player)->m_behav[iset]) {
         behav.SetAction(player->GetInfoset(iset)->GetAction(act));
       }
     }