Check all headers with clang-tidy

Author: tturocy

.clang-tidy

@@ -12,7 +12,6 @@ Checks: |
   cppcoreguidelines-prefer-member-initializer,
   misc-const-correctness
 WarningsAsErrors: '*'
-# Don't bother with wxWidgets headers
 HeaderFilterRegex: '.*'
 FormatStyle:     none
 User:            arbiter

Makefile.am

@@ -636,7 +636,7 @@ msw-msi:
 	light -ext WixUIExtension gambit.wixobj
 
 clang-tidy:
-	clang-tidy ${top_srcdir}/src/core/*.cc -- --std=c++17 -I ${top_srcdir}/src -DVERSION="" ${WX_CXXFLAGS}
-	clang-tidy ${top_srcdir}/src/games/*.cc ${top_srcdir}/src/games/*/*.cc -- --std=c++17 -I ${top_srcdir}/src -DVERSION="" ${WX_CXXFLAGS}
-	clang-tidy ${top_srcdir}/src/solvers/*/*.cc -- --std=c++17 -I ${top_srcdir}/src -DVERSION="" ${WX_CXXFLAGS}
-	clang-tidy ${top_srcdir}/src/tools/*/*.cc -- --std=c++17 -I ${top_srcdir}/src -DVERSION="" ${WX_CXXFLAGS}
+	clang-tidy ${top_srcdir}/src/core/*.cc -- --std=c++17 -I ${top_srcdir}/src -DVERSION=""
+	clang-tidy ${top_srcdir}/src/games/*.cc ${top_srcdir}/src/games/*/*.cc -- --std=c++17 -I ${top_srcdir}/src -DVERSION=""
+	clang-tidy ${top_srcdir}/src/solvers/*/*.cc -- --std=c++17 -I ${top_srcdir}/src -DVERSION=""
+	clang-tidy ${top_srcdir}/src/tools/*/*.cc -- --std=c++17 -I ${top_srcdir}/src -DVERSION=""

src/core/tinyxml.cc

@@ -120,12 +120,6 @@ TiXmlBase::StringToBuffer::StringToBuffer(const TIXML_STRING &str)
 TiXmlBase::StringToBuffer::~StringToBuffer() { delete[] buffer; }
 // End strange bug fix. -->
 
-TiXmlNode::TiXmlNode(NodeType _type)
-  : TiXmlBase(), parent(nullptr), type(_type), firstChild(nullptr), lastChild(nullptr),
-    prev(nullptr), next(nullptr)
-{
-}
-
 TiXmlNode::~TiXmlNode()
 {
   TiXmlNode *node = firstChild;

src/core/tinyxml.h

@@ -267,7 +267,7 @@ class TiXmlBase {
   {
     assert(p);
     if (encoding == TIXML_ENCODING_UTF8) {
-      *length = utf8ByteTable[*((unsigned char *)p)];
+      *length = utf8ByteTable[*(reinterpret_cast<const unsigned char *>(p))];
       assert(*length >= 0 && *length < 5);
     }
     else {
@@ -652,63 +652,27 @@ class TiXmlNode : public TiXmlBase {
   /// Returns true if this node has no children.
   bool NoChildren() const { return !firstChild; }
 
-  const TiXmlDocument *ToDocument() const
-  {
-    return (type == DOCUMENT) ? (const TiXmlDocument *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  const TiXmlElement *ToElement() const
-  {
-    return (type == ELEMENT) ? (const TiXmlElement *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  const TiXmlComment *ToComment() const
-  {
-    return (type == COMMENT) ? (const TiXmlComment *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  const TiXmlUnknown *ToUnknown() const
-  {
-    return (type == UNKNOWN) ? (const TiXmlUnknown *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  const TiXmlText *ToText() const
-  {
-    return (type == TEXT) ? (const TiXmlText *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  const TiXmlDeclaration *ToDeclaration() const
-  {
-    return (type == DECLARATION) ? (const TiXmlDeclaration *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
+  const TiXmlDocument *ToDocument() const;
+  const TiXmlElement *ToElement() const;
+  const TiXmlComment *ToComment() const;
+  const TiXmlUnknown *ToUnknown() const;
+  const TiXmlText *ToText() const;
+  const TiXmlDeclaration *ToDeclaration() const;
 
-  TiXmlDocument *ToDocument()
-  {
-    return (type == DOCUMENT) ? (TiXmlDocument *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlElement *ToElement()
-  {
-    return (type == ELEMENT) ? (TiXmlElement *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlComment *ToComment()
-  {
-    return (type == COMMENT) ? (TiXmlComment *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlUnknown *ToUnknown()
-  {
-    return (type == UNKNOWN) ? (TiXmlUnknown *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlText *ToText()
-  {
-    return (type == TEXT) ? (TiXmlText *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlDeclaration *ToDeclaration()
-  {
-    return (type == DECLARATION) ? (TiXmlDeclaration *)this : nullptr;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
+  TiXmlDocument *ToDocument();
+  TiXmlElement *ToElement();
+  TiXmlComment *ToComment();
+  TiXmlUnknown *ToUnknown();
+  TiXmlText *ToText();
+  TiXmlDeclaration *ToDeclaration();
 
   /** Create an exact duplicate of this node and return it. The memory must be deleted
           by the caller.
   */
   virtual TiXmlNode *Clone() const = 0;
 
 protected:
-  TiXmlNode(NodeType _type);
+  TiXmlNode(NodeType _type) : TiXmlBase(), type(_type) {}
 
   // Copy to the allocated object. Shared functionality between Clone, Copy constructor,
   // and the assignment operator.
@@ -722,16 +686,16 @@ class TiXmlNode : public TiXmlBase {
   // Figure out what is at *p, and parse it. Returns null if it is not an xml node.
   TiXmlNode *Identify(const char *start, TiXmlEncoding encoding);
 
-  TiXmlNode *parent;
+  TiXmlNode *parent{nullptr};
   NodeType type;
 
-  TiXmlNode *firstChild;
-  TiXmlNode *lastChild;
+  TiXmlNode *firstChild{nullptr};
+  TiXmlNode *lastChild{nullptr};
 
   TIXML_STRING value;
 
-  TiXmlNode *prev;
-  TiXmlNode *next;
+  TiXmlNode *prev{nullptr};
+  TiXmlNode *next{nullptr};
 
 private:
   TiXmlNode(const TiXmlNode &);          // not implemented.
@@ -750,29 +714,21 @@ class TiXmlAttribute : public TiXmlBase {
 
 public:
   /// Construct an empty attribute.
-  TiXmlAttribute() : TiXmlBase()
-  {
-    document = nullptr;
-    prev = next = nullptr;
-  }
+  TiXmlAttribute() : TiXmlBase(), document(nullptr) { prev = next = nullptr; }
 
 #ifdef TIXML_USE_STL
   /// std::string constructor.
   TiXmlAttribute(const std::string &_name, const std::string &_value)
+    : document(nullptr), name(_name), value(_value)
   {
-    name = _name;
-    value = _value;
-    document = nullptr;
     prev = next = nullptr;
   }
 #endif
 
   /// Construct an attribute with a name and value.
   TiXmlAttribute(const char *_name, const char *_value)
+    : document(nullptr), name(_name), value(_value)
   {
-    name = _name;
-    value = _value;
-    document = nullptr;
     prev = next = nullptr;
   }
 
@@ -804,13 +760,13 @@ class TiXmlAttribute : public TiXmlBase {
   /// STL std::string form.
   void SetName(const std::string &_name)
   {
-    StringToBuffer buf(_name);
+    const StringToBuffer buf(_name);
     SetName(buf.buffer ? buf.buffer : "error");
   }
   /// STL std::string form.
   void SetValue(const std::string &_value)
   {
-    StringToBuffer buf(_value);
+    const StringToBuffer buf(_value);
     SetValue(buf.buffer ? buf.buffer : "error");
   }
 #endif
@@ -884,12 +840,10 @@ class TiXmlAttributeSet {
   const TiXmlAttribute *Find(const char *name) const;
   TiXmlAttribute *Find(const char *name);
 
-private:
-  //*ME:	Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),
-  //*ME:	this class must be also use a hidden/disabled copy-constructor !!!
   TiXmlAttributeSet(const TiXmlAttributeSet &) = delete; // not allowed
   void operator=(const TiXmlAttributeSet &) = delete;    // not allowed (as TiXmlAttribute)
 
+private:
   TiXmlAttribute sentinel;
 };
 
@@ -948,7 +902,7 @@ class TiXmlElement : public TiXmlNode {
   int QueryFloatAttribute(const char *name, float *_value) const
   {
     double d;
-    int result = QueryDoubleAttribute(name, &d);
+    const int result = QueryDoubleAttribute(name, &d);
     if (result == TIXML_SUCCESS) {
       *_value = (float)d;
     }
@@ -982,16 +936,16 @@ class TiXmlElement : public TiXmlNode {
   /// STL std::string form.
   void SetAttribute(const std::string &name, const std::string &_value)
   {
-    StringToBuffer n(name);
-    StringToBuffer v(_value);
+    const StringToBuffer n(name);
+    const StringToBuffer v(_value);
     if (n.buffer && v.buffer) {
       SetAttribute(n.buffer, v.buffer);
     }
   }
   ///< STL std::string form.
   void SetAttribute(const std::string &name, int _value)
   {
-    StringToBuffer n(name);
+    const StringToBuffer n(name);
     if (n.buffer) {
       SetAttribute(n.buffer, _value);
     }
@@ -1139,23 +1093,24 @@ class TiXmlText : public TiXmlNode {
           normal, encoded text. If you want it be output as a CDATA text
           element, set the parameter _cdata to 'true'
   */
-  TiXmlText(const char *initValue) : TiXmlNode(TiXmlNode::TEXT)
+  TiXmlText(const char *initValue) : TiXmlNode(TiXmlNode::TEXT), cdata(false)
   {
     SetValue(initValue);
-    cdata = false;
   }
   ~TiXmlText() override = default;
 
 #ifdef TIXML_USE_STL
   /// Constructor.
-  TiXmlText(const std::string &initValue) : TiXmlNode(TiXmlNode::TEXT)
+  TiXmlText(const std::string &initValue) : TiXmlNode(TiXmlNode::TEXT), cdata(false)
   {
     SetValue(initValue);
-    cdata = false;
   }
 #endif
 
-  TiXmlText(const TiXmlText &copy) : TiXmlNode(TiXmlNode::TEXT) { copy.CopyTo(this); }
+  TiXmlText(const TiXmlText &copy) : TiXmlNode(TiXmlNode::TEXT), cdata(copy.cdata)
+  {
+    copy.CopyTo(this);
+  }
   void operator=(const TiXmlText &base) { base.CopyTo(this); }
 
   /// Write this text object to a FILE stream.
@@ -1314,12 +1269,12 @@ class TiXmlDocument : public TiXmlNode {
   bool LoadFile(const std::string &filename,
                 TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING) ///< STL std::string version.
   {
-    StringToBuffer f(filename);
+    const StringToBuffer f(filename);
     return (f.buffer && LoadFile(f.buffer, encoding));
   }
   bool SaveFile(const std::string &filename) const ///< STL std::string version.
   {
-    StringToBuffer f(filename);
+    const StringToBuffer f(filename);
     return (f.buffer && SaveFile(f.buffer));
   }
 #endif
@@ -1517,9 +1472,9 @@ class TiXmlDocument : public TiXmlNode {
 class TiXmlHandle {
 public:
   /// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
-  TiXmlHandle(TiXmlNode *_node) { this->node = _node; }
+  TiXmlHandle(TiXmlNode *_node) : node(_node) {}
   /// Copy constructor
-  TiXmlHandle(const TiXmlHandle &ref) { this->node = ref.node; }
+  TiXmlHandle(const TiXmlHandle &ref) = default;
   TiXmlHandle operator=(const TiXmlHandle &ref)
   {
     this->node = ref.node;
@@ -1590,6 +1545,56 @@ class TiXmlHandle {
   TiXmlNode *node;
 };
 
+inline const TiXmlDocument *TiXmlNode::ToDocument() const
+{
+  return (type == DOCUMENT) ? dynamic_cast<const TiXmlDocument *>(this) : nullptr;
+}
+inline const TiXmlElement *TiXmlNode::ToElement() const
+{
+  return (type == ELEMENT) ? dynamic_cast<const TiXmlElement *>(this) : nullptr;
+}
+inline const TiXmlComment *TiXmlNode::ToComment() const
+{
+  return (type == COMMENT) ? dynamic_cast<const TiXmlComment *>(this) : nullptr;
+}
+inline const TiXmlUnknown *TiXmlNode::ToUnknown() const
+{
+  return (type == UNKNOWN) ? dynamic_cast<const TiXmlUnknown *>(this) : nullptr;
+}
+inline const TiXmlText *TiXmlNode::ToText() const
+{
+  return (type == TEXT) ? dynamic_cast<const TiXmlText *>(this) : nullptr;
+}
+inline const TiXmlDeclaration *TiXmlNode::ToDeclaration() const
+{
+  return (type == DECLARATION) ? dynamic_cast<const TiXmlDeclaration *>(this) : nullptr;
+}
+
+inline TiXmlDocument *TiXmlNode::ToDocument()
+{
+  return (type == DOCUMENT) ? dynamic_cast<TiXmlDocument *>(this) : nullptr;
+}
+inline TiXmlElement *TiXmlNode::ToElement()
+{
+  return (type == ELEMENT) ? dynamic_cast<TiXmlElement *>(this) : nullptr;
+}
+inline TiXmlComment *TiXmlNode::ToComment()
+{
+  return (type == COMMENT) ? dynamic_cast<TiXmlComment *>(this) : nullptr;
+}
+inline TiXmlUnknown *TiXmlNode::ToUnknown()
+{
+  return (type == UNKNOWN) ? dynamic_cast<TiXmlUnknown *>(this) : nullptr;
+}
+inline TiXmlText *TiXmlNode::ToText()
+{
+  return (type == TEXT) ? dynamic_cast<TiXmlText *>(this) : nullptr;
+}
+inline TiXmlDeclaration *TiXmlNode::ToDeclaration()
+{
+  return (type == DECLARATION) ? dynamic_cast<TiXmlDeclaration *>(this) : nullptr;
+}
+
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif

src/games/agg/agg.cc

@@ -38,12 +38,11 @@ AGG::AGG(int numPlayers, std::vector<int> &_actions, int numANodes, int _numPNod
          vector<projtype> &projTypes, vector<vector<aggdistrib>> &projS,
          vector<vector<vector<config>>> &proj, vector<vector<projtype>> &projF,
          vector<vector<vector<int>>> &Po, vector<aggdistrib> &P, vector<aggpayoff> &_payoffs)
-  : numPlayers(numPlayers), totalActions(0), maxActions(0), numActionNodes(numANodes),
-    numPNodes(_numPNodes), actionSets(_actionSets), neighbors(neighb), projectionTypes(projTypes),
-    payoffs(_payoffs), projection(proj), projectedStrat(projS), fullProjectedStrat(projS),
-    projFunctions(projF), Porder(Po), Pr(P), isPure(numANodes, true),
-    node2Action(numANodes, vector<int>(numPlayers)), cache(numPlayers + 1),
-    player2Class(numPlayers), kSymStrategyOffset(1, 0)
+  : numPlayers(numPlayers), numActionNodes(numANodes), numPNodes(_numPNodes),
+    actionSets(_actionSets), neighbors(neighb), projectionTypes(projTypes), payoffs(_payoffs),
+    projection(proj), projectedStrat(projS), fullProjectedStrat(projS), projFunctions(projF),
+    Porder(Po), Pr(P), isPure(numANodes, true), node2Action(numANodes, vector<int>(numPlayers)),
+    cache(numPlayers + 1), player2Class(numPlayers), kSymStrategyOffset(1, 0)
 
 {
   // actions

src/games/agg/agg.h

@@ -170,8 +170,8 @@ class AGG {
   int numPlayers;
   std::vector<int> actions;
   std::vector<int> strategyOffset;
-  int totalActions;
-  int maxActions;
+  int totalActions{0};
+  int maxActions{0};
 
   int numActionNodes; // |S|
   int numPNodes;      // |P|