comparison src/Matcher.cpp @ 212:827176d3b6ec

Naming

 bool
 Matcher::isAvailable(int i, int j)
 {
     if (m_firstPM) {
         if (isInRange(i, j)) {
-            return (m_bestPathCost[i][j - m_first[i]] != InvalidPathCost);
+            return (m_bestPathCost[i][j - m_first[i]] != INVALID_PATHCOST);
         } else {
             return false;
         }
     } else {
         return m_otherMatcher->isAvailable(j, i);

 {
     if (m_firstPM) {
 
         if (i < 0 || i >= int(m_first.size())) return false;
         for (auto c: m_bestPathCost[i]) {
-            if (c != InvalidPathCost) return true;
+            if (c != INVALID_PATHCOST) return true;
         }
         return false;
 
     } else {
         return m_otherMatcher->isColAvailable(i);

 Matcher::isColAvailable(int j)
 {
     if (m_firstPM) {
         for (int i = 0; i < int(m_first.size()); ++i) {
             if (j >= m_first[i] && j < m_last[i]) {
-                if (m_bestPathCost[i][j - m_first[i]] != InvalidPathCost) {
+                if (m_bestPathCost[i][j - m_first[i]] != INVALID_PATHCOST) {
                     return true;
                 }
             }
         }
         return false;

             throw "Distance not available";
         }
 #endif
         distance_t dist = m_distance[i][j - m_first[i]];
 #ifdef PERFORM_ERROR_CHECKS
-        if (dist == InvalidDistance) {
+        if (dist == INVALID_DISTANCE) {
             cerr << "ERROR: Matcher::getDistance(" << i << ", " << j << "): "
                  << "Location is in range, but distance ("
                  << distance_print_t(dist)
                  << ") is invalid or has not been set" << endl;
             throw "Distance not available";

     m_first.resize(m_distXSize, 0);
     m_last.resize(m_distXSize, 0);
 
     if (m_firstPM) {
         int distSize = (m_params.maxRunCount + 1) * m_blockSize;
-        m_bestPathCost.resize(m_distXSize, pathcostvec_t(distSize, InvalidPathCost));
-        m_distance.resize(m_distXSize, distancevec_t(distSize, InvalidDistance));
+        m_bestPathCost.resize(m_distXSize, pathcostvec_t(distSize, INVALID_PATHCOST));
+        m_distance.resize(m_distXSize, distancevec_t(distSize, INVALID_DISTANCE));
         m_advance.resize(m_distXSize, advancevec_t(distSize, AdvanceNone));
     }
 }
 
 void

 }
 
 pathcost_t
 Matcher::addToCost(pathcost_t cost, pathcost_t increment)
 {
-    if (MaxPathCost - increment < cost) {
-        return MaxPathCost;
+    if (PATHCOST_MAX - increment < cost) {
+        return PATHCOST_MAX;
     } else {
         return cost + pathcost_t(increment);
     }
 }
 

     if (dir == AdvanceBoth) {
         increment = pathcost_t(increment * m_params.diagonalWeight);
     }
 
     pathcost_t newValue = addToCost(value, increment);
-    if (newValue == MaxPathCost) {
+    if (newValue == PATHCOST_MAX) {
         cerr << "ERROR: Path cost overflow at i=" << i << ", j=" << j << ": "
-             << value << " + " << increment << " >= " << MaxPathCost << endl;
-        newValue = MaxPathCost;
+             << value << " + " << increment << " >= " << PATHCOST_MAX << endl;
+        newValue = PATHCOST_MAX;
     }
     
     if (m_firstPM) {
 
         setDistance(i, j, distance);

         if (idx < 0 || size_t(idx) == m_otherMatcher->m_distance[j].size()) {
             // This should never happen, but if we allow arbitrary
             // pauses in either direction, and arbitrary lengths at
             // end, it is better than a segmentation fault.
             cerr << "Emergency resize: " << idx << " -> " << idx * 2 << endl;
-            m_otherMatcher->m_bestPathCost[j].resize(idx * 2, InvalidPathCost);
-            m_otherMatcher->m_distance[j].resize(idx * 2, InvalidDistance);
+            m_otherMatcher->m_bestPathCost[j].resize(idx * 2, INVALID_PATHCOST);
+            m_otherMatcher->m_distance[j].resize(idx * 2, INVALID_DISTANCE);
             m_otherMatcher->m_advance[j].resize(idx * 2, AdvanceNone);
         }
 
         m_otherMatcher->setDistance(j, i, distance);
         m_otherMatcher->setPathCost(j, i, dir, newValue);