bring back compatibility with C++98

- make type explicit (remove use of auto)
- make iterators in for-loops explicit
- use unordered_set only if C++ >= 2011, otherwise use set
- include limits if (c)stdint not available
- replace nullptr by NULL

Author: svigerske

CoinUtils/src/CoinDynamicConflictGraph.cpp

@@ -12,7 +12,11 @@ using namespace std;
 
 CoinDynamicConflictGraph::CoinDynamicConflictGraph ( size_t _size ) :
   CoinConflictGraph ( _size ),
+#if __cplusplus >= 201103L
   nodeConflicts( vector< ConflictSetType >( _size, ConflictSetType( 2048 ) ) ),
+#else
+  nodeConflicts( vector< ConflictSetType >( _size ) ),
+#endif
   nodeCliques(std::vector< std::vector<size_t> >( _size )),
   nDirectConflicts( _size ),
   totalCliqueElements( 0 )
@@ -48,7 +52,7 @@ void CoinDynamicConflictGraph::addClique( size_t size, const size_t elements[] )
   cliques.push_back( CCCliqueType(elements, elements+size) );
 
   // checking if elements are not sorted
-  auto &clq = *cliques.rbegin();
+  CCCliqueType &clq = *cliques.rbegin();
   bool sorted = true;
   for ( size_t i=0 ; i<clq.size()-1 ; ++i ) {
     if (clq[i] > clq[i+1]) {
@@ -69,7 +73,7 @@ bool CoinDynamicConflictGraph::conflicting ( size_t n1, size_t n2 ) const
   if ( cIt != nodeConflicts[n1].end() )
     return true;
 
-  const auto &nodeCliquesN1 = nodeCliques[n1];
+  const std::vector<size_t> &nodeCliquesN1 = nodeCliques[n1];
 
   if (nodeCliquesN1.size()==0)
       return false;
@@ -127,7 +131,16 @@ CoinDynamicConflictGraph::CoinDynamicConflictGraph (
   const char* sense,
   const double* rowRHS,
   const double* rowRange )
-  : CoinDynamicConflictGraph( numCols*2 )
+  :
+  CoinConflictGraph ( numCols*2 ),
+#if __cplusplus >= 201103L
+  nodeConflicts( vector< ConflictSetType >( numCols*2, ConflictSetType( 2048 ) ) ),
+#else
+  nodeConflicts( vector< ConflictSetType >( numCols*2 ) ),
+#endif
+  nodeCliques(std::vector< std::vector<size_t> >( numCols*2 )),
+  nDirectConflicts( numCols*2 ),
+  totalCliqueElements( 0 )
 {
   newBounds_.clear();
   const int *idxs = matrixByRow->getIndices();
@@ -453,18 +466,19 @@ void CoinDynamicConflictGraph::recomputeDegree()
     nConflicts_ = 0;
 
     for ( size_t i=0 ; (i<size_) ; ++i ) {
-        const auto &nodeDirConf = nodeConflicts[i];
+        const ConflictSetType &nodeDirConf = nodeConflicts[i];
 
         modified.clear();
 
         // setting iv for initial ements
         modified.insert(modified.end(), nodeDirConf.begin(), nodeDirConf.end());
         modified.push_back( i );
-        for ( const auto &el : modified )
-          iv[el] = 1;
+        for ( vector< int >::const_iterator it = modified.begin(); it != modified.end(); ++it )
+          iv[*it] = 1;
 
-        for ( const auto &iclq : nodeCliques[i] ) {
-          for ( const auto &el : cliques[iclq] ) {
+        for ( std::vector<size_t>::const_iterator it1 = nodeCliques[i].begin(); it1 != nodeCliques[i].end(); ++it1 ) {
+          for ( CCCliqueType::const_iterator it2 = cliques[*it1].begin(); it2 != cliques[*it1].end(); ++it2 ) {
+                size_t el = *it2;
                 if ( iv[el] == 0 ) {
                     iv[el] = 1;
                     modified.push_back(el);
@@ -474,8 +488,8 @@ void CoinDynamicConflictGraph::recomputeDegree()
 
         degree_[i] = modified.size() - 1;
 
-        for ( const auto &el : modified )
-            iv[el] = 0;
+        for ( vector< int >::const_iterator it = modified.begin(); it != modified.end(); ++it )
+            iv[*it] = 0;
 
         minDegree_ = min(minDegree_, degree_[i]);
         maxDegree_ = max(maxDegree_, degree_[i]);
@@ -538,9 +552,17 @@ std::vector<std::string> CoinDynamicConflictGraph::differences(const CGraph* cgr
 #endif
 
 CoinDynamicConflictGraph::CoinDynamicConflictGraph( const CoinStaticConflictGraph *cgraph, const size_t n, const size_t elements[] )
-  : CoinDynamicConflictGraph( n )
+  : CoinConflictGraph ( n ),
+#if __cplusplus >= 201103L
+  nodeConflicts( vector< ConflictSetType >( n, ConflictSetType( 2048 ) ) ),
+#else
+  nodeConflicts( vector< ConflictSetType >( n ) ),
+#endif
+  nodeCliques(std::vector< std::vector<size_t> >( n )),
+  nDirectConflicts( n ),
+  totalCliqueElements( 0 )
 {
-  const auto NOT_INCLUDED = numeric_limits<size_t>::max();
+  const size_t NOT_INCLUDED = numeric_limits<size_t>::max();
 
   vector< size_t > newIdx( cgraph->size(), NOT_INCLUDED );
 
@@ -552,9 +574,9 @@ CoinDynamicConflictGraph::CoinDynamicConflictGraph( const CoinStaticConflictGrap
 
   // direct neighbors in static cgraph
   for ( size_t i=0 ; (i<n) ; ++i ) {
-    const auto nidx = elements[i];
-    const auto *neighs = cgraph->nodeNeighs( nidx );
-    const auto nNeighs = cgraph->nConflictsNode[ nidx ];
+    const size_t nidx = elements[i];
+    const size_t *neighs = cgraph->nodeNeighs( nidx );
+    const size_t nNeighs = cgraph->nConflictsNode[ nidx ];
 
     realNeighs.clear();
     for ( size_t j=0 ; (j<nNeighs) ; ++j )
@@ -586,12 +608,12 @@ CoinDynamicConflictGraph::CoinDynamicConflictGraph( const CoinStaticConflictGrap
 
 std::pair< size_t, const size_t* > CoinDynamicConflictGraph::conflictingNodes ( size_t node, size_t* temp ) const
 {
-  const auto &nodeCliquesNode = nodeCliques[node];
-  const auto &nconf = nodeConflicts[node];
+  const std::vector<size_t> &nodeCliquesNode = nodeCliques[node];
+  const ConflictSetType &nconf = nodeConflicts[node];
   if (nodeCliquesNode.size()==0) {
     size_t i=0;
-    for ( const auto &n : nconf )
-      temp[i++] = n;
+    for ( ConflictSetType::const_iterator it = nconf.begin(); it != nconf.begin(); ++it )
+      temp[i++] = *it;
 
     return pair< size_t, const size_t* >(nconf.size(), temp);
   }
@@ -604,16 +626,16 @@ std::pair< size_t, const size_t* > CoinDynamicConflictGraph::conflictingNodes (
     for ( vector< size_t >::const_iterator
       vit = nodeCliquesNode.begin() ; vit != nodeCliquesNode.end() ; ++ vit )
     {
-      const auto &s = cliques[*vit];
-      for ( const auto &n : s)
-        if (n != node)
-          res.insert(n);
+      const CCCliqueType &s = cliques[*vit];
+      for ( CCCliqueType::const_iterator it = s.begin(); it != s.end(); ++it )
+        if (*it != node)
+          res.insert(*it);
     }
 
     // copying final result
     size_t i=0;
-    for ( const auto &n : res )
-      temp[i++] = n;
+    for ( ConflictSetType::const_iterator it = res.begin(); it != res.end(); ++it )
+      temp[i++] = *it;
 
     return pair< size_t, const size_t* >(res.size(), temp);
   }
@@ -623,7 +645,7 @@ std::pair< size_t, const size_t* > CoinDynamicConflictGraph::conflictingNodes (
 
 bool CoinDynamicConflictGraph::elementInClique( size_t idxClique, size_t node ) const
 {
-  const auto &clique = cliques[idxClique];
+  const CCCliqueType &clique = cliques[idxClique];
 
   return std::binary_search(clique.begin(), clique.end(), node);
 }

CoinUtils/src/CoinDynamicConflictGraph.hpp

@@ -14,8 +14,13 @@ class CoinStaticConflictGraph;
 
 class CoinPackedMatrix;
 
+#if __cplusplus >= 201103L
 #include <unordered_set>
 typedef std::unordered_set< size_t > ConflictSetType;
+#else
+#include <set>
+typedef std::set< size_t > ConflictSetType;
+#endif
 typedef std::vector< size_t > CCCliqueType;
 
 /**

CoinUtils/src/CoinStaticConflictGraph.cpp

@@ -4,7 +4,6 @@
 
 #include "CoinDynamicConflictGraph.hpp"
 
-
 using namespace std;
 
 CoinStaticConflictGraph::CoinStaticConflictGraph ( const CoinDynamicConflictGraph *cgraph ) :
@@ -23,12 +22,12 @@ CoinStaticConflictGraph::CoinStaticConflictGraph ( const CoinDynamicConflictGrap
   // copying direct conflicts
   startConfNodes[0] = 0;
   for ( size_t i=0 ; (i<size()) ; ++i ) {
-    const auto &s = cgraph->nodeConflicts[i];
+    const ConflictSetType& s = cgraph->nodeConflicts[i];
     startConfNodes[i+1] = startConfNodes[i] + (size_t)s.size();
     nConflictsNode[i] = (size_t) s.size();
 
     size_t iconf = startConfNodes[i];
-    for ( auto sit = s.begin() ; ( sit != s.end() ) ; ++sit, ++iconf ) {
+    for ( ConflictSetType::const_iterator sit = s.begin() ; sit != s.end() ; ++sit, ++iconf ) {
       conflicts[iconf] = *sit;
     } // copying node direct conflicts
   } // all nodes
@@ -37,12 +36,12 @@ CoinStaticConflictGraph::CoinStaticConflictGraph ( const CoinDynamicConflictGrap
   startClique[0] = 0;
   for ( size_t ic=0 ; ( ic<(size_t)cgraph->cliques.size() ) ; ++ic )
   {
-    const auto &clique = cgraph->cliques[ic];
+    const CCCliqueType& clique = cgraph->cliques[ic];
     cliqueSize[ic] = (size_t)clique.size();
     startClique[ic+1] = startClique[ic] + cliqueSize[ic];
     size_t pc = startClique[ic];
     // copying clique contents
-    for ( auto cit = clique.begin() ; ( cit != clique.end() ) ; ++cit, ++pc ) {
+    for ( CCCliqueType::const_iterator cit = clique.begin() ; ( cit != clique.end() ) ; ++cit, ++pc ) {
       cliques[pc] = *cit;
       ++nNodeCliques[*cit];
     }
@@ -87,10 +86,10 @@ CoinStaticConflictGraph::CoinStaticConflictGraph ( const CoinStaticConflictGraph
   * Constructor that creates a subgraph
   * induced by a set of nodes
   */
-CoinStaticConflictGraph::CoinStaticConflictGraph( const CoinStaticConflictGraph *cgraph, size_t n, const size_t elements[] )
-  : CoinStaticConflictGraph( CoinDynamicConflictGraph(cgraph, n, elements) )
-{
-}
+//CoinStaticConflictGraph::CoinStaticConflictGraph( const CoinStaticConflictGraph *cgraph, size_t n, const size_t elements[] )
+//  : CoinStaticConflictGraph( CoinDynamicConflictGraph(cgraph, n, elements) )
+//{
+//}
 
 #include <set>
 
@@ -167,11 +166,10 @@ const size_t *CoinStaticConflictGraph::nodeNeighs(size_t node) const
   return &conflicts[ startConfNodes[node] ];
 }
 
-CoinStaticConflictGraph::CoinStaticConflictGraph( const CoinDynamicConflictGraph &cgraph )
-  : CoinStaticConflictGraph( &cgraph )
-{
-
-}
+//CoinStaticConflictGraph::CoinStaticConflictGraph( const CoinDynamicConflictGraph &cgraph )
+//  : CoinStaticConflictGraph( &cgraph )
+//{
+//}
 
 
 

CoinUtils/src/CoinStaticConflictGraph.hpp

@@ -22,7 +22,7 @@ class CoinStaticConflictGraph : public CoinConflictGraph
   /**
    * Default constructor
    */
-  CoinStaticConflictGraph ( const CoinDynamicConflictGraph &cgraph );
+  //CoinStaticConflictGraph ( const CoinDynamicConflictGraph &cgraph );
 
   /**
    * Copy constructor
@@ -33,7 +33,7 @@ class CoinStaticConflictGraph : public CoinConflictGraph
    * Constructor that creates a subgraph
    * induced by a set of nodes
    */
-  CoinStaticConflictGraph ( const CoinStaticConflictGraph *cgraph, size_t n, const size_t elements[] );
+  //CoinStaticConflictGraph ( const CoinStaticConflictGraph *cgraph, size_t n, const size_t elements[] );
 
   /**
    * Checks if two nodes conflict

CoinUtils/src/bron_kerbosch.cpp

@@ -65,7 +65,7 @@ ArrayOfVertices* array_of_vertices_create(size_t size) {
 void array_of_vertices_free(ArrayOfVertices *av) {
     delete[] av->vertices;
     delete av;
-    av = nullptr;
+    av = NULL;
 }
 
 ListOfVertices* list_of_vertices_create() {
@@ -76,7 +76,7 @@ ListOfVertices* list_of_vertices_create() {
 
 void list_of_vertices_free(ListOfVertices* lv) {
     delete lv;
-    lv = nullptr;
+    lv = NULL;
 }
 
 BronKerbosch* bk_create(const CGraph *cgraph) {
@@ -88,9 +88,9 @@ BronKerbosch* bk_create(const CGraph *cgraph) {
     size_t *neighs = new size_t[cgSize];
 
     bk->vertices.reserve(cgSize);
-    bk->bit = nullptr;
-    bk->mask = nullptr;
-    bk->clqSet = nullptr;
+    bk->bit = NULL;
+    bk->mask = NULL;
+    bk->clqSet = NULL;
 
     for(size_t i = 0; i < cgSize; i++) {
         size_t realDegree = cgraph_degree(cgraph, i);
@@ -174,16 +174,16 @@ void bk_free(BronKerbosch **_bk) {
     }
 
     delete bk;
-    *_bk = nullptr;
+    *_bk = NULL;
 }
 
 std::vector<size_t> exclude_neighbors_u(const BronKerbosch *bk, const ListOfVertices *P, size_t u) {
     std::vector<size_t> P_excluding_N_u;
     P_excluding_N_u.reserve(bk->nVertices);
 
-    for(const size_t &vertex : P->vertices) {
-        if(!cgraph_conflicting_nodes(bk->cgraph, bk->vertices[u].id, bk->vertices[vertex].id)) {
-            P_excluding_N_u.push_back(vertex);
+    for(std::list<size_t>::const_iterator it = P->vertices.begin(); it != P->vertices.end(); ++it ) {
+        if(!cgraph_conflicting_nodes(bk->cgraph, bk->vertices[u].id, bk->vertices[*it].id)) {
+            P_excluding_N_u.push_back(*it);
         }
     }
 
@@ -271,10 +271,10 @@ ListOfVertices* create_new_P(const BronKerbosch *bk, const ListOfVertices *P, co
     ListOfVertices *newP = list_of_vertices_create();
 
     //newP = P intersection N(v)
-    for(const size_t &vertex : P->vertices) {
-        if(cgraph_conflicting_nodes(bk->cgraph, bk->vertices[v].id, bk->vertices[vertex].id)) {
-            newP->vertices.push_back(vertex);
-            newP->totalWeight += bk->vertices[vertex].weight;
+    for(std::list<size_t>::const_iterator it = P->vertices.begin(); it != P->vertices.end(); ++it ) {
+        if(cgraph_conflicting_nodes(bk->cgraph, bk->vertices[v].id, bk->vertices[*it].id)) {
+            newP->vertices.push_back(*it);
+            newP->totalWeight += bk->vertices[*it].weight;
         }
     }
 
@@ -304,7 +304,8 @@ void bron_kerbosch_algorithm(BronKerbosch *bk, const ArrayOfVertices *C, ListOfV
         const size_t u = *(P->vertices.begin());
         const std::vector<size_t> &P_excluding_N_u = exclude_neighbors_u(bk, P, u);
 
-        for(const size_t &v : P_excluding_N_u) {
+        for(std::vector<size_t>::const_iterator it = P_excluding_N_u.begin(); it != P_excluding_N_u.end(); ++it ) {
+            size_t v = *it;
             ArrayOfVertices *newC = create_new_C(bk, C, v);
             ArrayOfVertices *newS = create_new_S(bk, S, v);
             ListOfVertices *newP = create_new_P(bk, P, v);

CoinUtils/src/cgraph.cpp

@@ -9,6 +9,14 @@
 #include "clique.h"
 #include "vint_set.h"
 
+#ifdef COINUTILS_HAS_CSTDINT
+#include <cstdint>
+#elif defined(COINUTILS_HAS_STDINT_H)
+#include <stdint.h>
+#else
+#include <limits>
+#endif
+
 #define LINE_SIZE 2048
 #define MAX_NAME_SIZE 64
 
@@ -248,7 +256,8 @@ bool cgraph_conflicting_nodes(const CGraph *cgraph, const size_t i, const size_t
     }
 
     FIND_IN_CLIQUES:
-    for (const size_t idx : cgraph->nodeCliques[i]) {
+    for (std::vector<size_t>::const_iterator it = cgraph->nodeCliques[i].begin(); it != cgraph->nodeCliques[i].end(); ++it) {
+        size_t idx = *it;
         if (clq_set_clique_has_element(cgraph->clqSet, idx, j)) {
 #ifdef DEBUG
             assert(clq_set_clique_has_element(cgraph->clqSet, idx, i));
@@ -284,7 +293,8 @@ size_t cgraph_get_all_conflicting(const CGraph *cgraph, size_t node, size_t *nei
     }
 
     /* now filling information from cliques, i.e., implicitly stored conflicts */
-    for (const size_t idxClique : cgraph->nodeCliques[node]) {
+    for (std::vector<size_t>::const_iterator it = cgraph->nodeCliques[node].begin(); it != cgraph->nodeCliques[node].end(); ++it) {
+        const size_t idxClique = *it;
         const size_t *clqEl = clq_set_clique_elements(cgraph->clqSet, idxClique);
         for (size_t j = 0; j < clq_set_clique_size(cgraph->clqSet, idxClique); j++) {
             if (!iv[clqEl[j]]) {
@@ -704,7 +714,8 @@ void cgraph_recompute_degree(CGraph *cgraph) {
             }
 
             //conflicts stored as cliques
-            for (const size_t idxClique : cgraph->nodeCliques[i]) {
+            for (std::vector<size_t>::const_iterator it = cgraph->nodeCliques[i].begin(); it != cgraph->nodeCliques[i].end(); ++it) {
+                const size_t idxClique = *it;
                 const size_t *clqEl = clq_set_clique_elements(cgraph->clqSet, idxClique);
                 for (size_t k = 0; k < clq_set_clique_size(cgraph->clqSet, idxClique); k++) {
                     if (!iv[clqEl[k]] && clqEl[k] != i) {
@@ -771,7 +782,8 @@ size_t cgraph_get_best_n_neighbors(const CGraph *cgraph, size_t node, const doub
 
     /* conflicts stored in cliques */
     const CliqueSet *clqSet = cgraph->clqSet;
-    for (const size_t clique : cgraph->nodeCliques[node]) {
+    for (std::vector<size_t>::const_iterator it = cgraph->nodeCliques[node].begin(); it != cgraph->nodeCliques[node].end(); ++it) {
+        const size_t clique = *it;
         const size_t *el = clq_set_clique_elements(clqSet, clique);
         for (size_t j = 0; j < clq_set_clique_size(clqSet, clique); j++) {
 #ifdef DEBUG