Update mussa to build on ubuntu 10.04 with qt 4.6.2 +boost 1.40.0.1

[mussa.git] / alg / conserved_path.cpp

diff --git a/alg/conserved_path.cpp b/alg/conserved_path.cpp
index af8af7d4ba5ae356b8775330b38d5e3ce64d1a43..1edb374065c2027d3cf1a4e37dec80b17ebea9c6 100644 (file)
--- a/alg/conserved_path.cpp
+++ b/alg/conserved_path.cpp
@@ -1,30 +1,34 @@
 #include "alg/conserved_path.hpp"
-#include <stdexcept>
+#include "mussa_exceptions.hpp"
 
 using namespace std;
 
 /////////////////////
 
 ConservedPath::ConservedPath()
-  : score(0.0),
+  : window_size(0),
+    score(0.0),
     track_indexes()
 {
 }
 
 ConservedPath::ConservedPath(const ConservedPath::ConservedPath& other)
-  : score(other.score),
+  : window_size(other.window_size),
+    score(other.score),
     track_indexes(other.track_indexes)
 {
 }
 
-ConservedPath::ConservedPath(double s, ConservedPath::path_type path)
-  : score(s),
+ConservedPath::ConservedPath(size_t win_size, double s, ConservedPath::path_type path)
+  : window_size(win_size),
+    score(s),
     track_indexes(path)
 {
 }
 
 void ConservedPath::clear()
 {
+  window_size = 0;
   score = 0.0;
   track_indexes.clear();
 }
@@ -50,9 +54,36 @@ bool operator!=(const ConservedPath::ConservedPath& a,
   return not (a == b);
 }
 
+bool operator<(const ConservedPath& a, const ConservedPath &b)
+{
+  ConservedPath::const_iterator a_i = a.begin();
+  ConservedPath::const_iterator b_i = b.begin();
+  for(; a_i != a.end() and b_i != b.end(); ++a_i, ++b_i)
+  {
+    if (*a_i < *b_i) {
+      return true;
+    } else if (*a_i > *b_i) {
+      return false;
+    }
+    // else they're equal and we continue to loop
+  }
+  // now handle mismatched lengths
+  if (a_i == a.end() and b_i == b.end()) {
+    return false; // since the two paths are equal
+  } else if (a_i == a.end()) {
+    return true; // a is shorter than b
+  } else if (b_i == b.end()) {
+    return false; // b is shorter than a
+  } else {
+    // something went horribly wrong
+    throw std::runtime_error("ConservedPath operator< had a fatal logic error");
+  }
+}
+
 std::ostream& operator<<(std::ostream& out, const ConservedPath& path)
 {
-  out << "<path score=" << path.score 
+  out << "<path win_size" << path.window_size 
+      << " score=" << path.score 
       << " len=" << path.track_indexes.size();
   if (path.track_indexes.size() > 0)
   {
@@ -114,7 +145,7 @@ ConservedPath::const_iterator ConservedPath::end() const
 bool ConservedPath::nextTo(const ConservedPath& next) const
 {
   if (size() != next.size() ) {
-    throw runtime_error("paths must be the same length");
+    throw conserved_path_size_mismatch("paths must be the same length");
   }    
   ConservedPath::const_iterator this_itor = begin();
   ConservedPath::const_iterator next_itor = next.begin();
@@ -142,34 +173,23 @@ vector<bool> ConservedPath::reverseComplimented() const
 
 }
 
-/////////////////////
-ExtendedConservedPath::ExtendedConservedPath()
-  : ConservedPath(),
-    window_size(0)
-{
-}
-
-ExtendedConservedPath::ExtendedConservedPath(const ExtendedConservedPath& other)
-  : ConservedPath(other), 
-    window_size(other.window_size)
-{
-}
-
-ExtendedConservedPath::ExtendedConservedPath(int win_size, ConservedPath other)
-  : ConservedPath(other), 
-    window_size(win_size)
-{
-}
-
-ExtendedConservedPath::ExtendedConservedPath(int win_size, 
-                                             double s, 
-                                             ConservedPath::path_type p)
-  : ConservedPath(s, p),
-    window_size(win_size)
+std::vector<ConservedPath::path_element> ConservedPath::normalizedIndexes() const
 {
+  vector<path_element> paths;
+  for (ConservedPath::const_iterator this_itor = begin(); 
+       this_itor != end(); 
+       ++this_itor)
+  {
+    if (*this_itor < 0) {
+      paths.push_back(-(*this_itor)-window_size);
+    } else {
+      paths.push_back(*this_itor);
+    }
+  }
+  return paths;
 }
 
-ExtendedConservedPath& ExtendedConservedPath::extend(int growth)
+ConservedPath& ConservedPath::extend(int growth)
 {
   window_size += growth;
   
@@ -186,10 +206,3 @@ ExtendedConservedPath& ExtendedConservedPath::extend(int growth)
   return *this;
 }
 
-std::ostream& operator<<(std::ostream& out, const ExtendedConservedPath& path)
-{
-  out << "<extended_path size=" << path.window_size;
-  out << (ConservedPath&)path;
-  return out;
-}
-