Load N sequences in Mussa::load

[mussa.git] / alg / mussa.cpp

diff --git a/alg/mussa.cpp b/alg/mussa.cpp
index 6978ef24356f0775ead016f6deabb8aabe9bbca1..82b1d4a6585e49c1a946e9093413b0be357ab570 100644 (file)
--- a/alg/mussa.cpp
+++ b/alg/mussa.cpp
@@ -32,8 +32,8 @@ Mussa::Mussa()
   : color_mapper(new AnnotationColors)
 {
   clear();
-  connect(&the_paths, SIGNAL(progress(const std::string&, int, int)), 
-          this, SIGNAL(progress(const std::string&, int, int)));
+  connect(&the_paths, SIGNAL(progress(const QString&, int, int)), 
+          this, SIGNAL(progress(const QString&, int, int)));
 }
 
 Mussa::Mussa(const Mussa& m)
@@ -49,8 +49,14 @@ Mussa::Mussa(const Mussa& m)
     analysis_path(m.analysis_path),
     dirty(m.dirty)
 {
-  connect(&the_paths, SIGNAL(progress(const std::string&, int, int)), 
-          this, SIGNAL(progress(const std::string&, int, int)));
+  connect(&the_paths, SIGNAL(progress(const QString&, int, int)), 
+          this, SIGNAL(progress(const QString&, int, int)));
+}
+
+MussaRef Mussa::init() 
+{
+  boost::shared_ptr<Mussa> m(new Mussa());
+  return m;
 }
 
 boost::filesystem::path Mussa::get_analysis_path() const
@@ -79,7 +85,15 @@ Mussa::clear()
   the_seqs.clear();
   the_paths.clear();
   analysis_path = fs::path();
-  dirty = false;
+  set_dirty(false);
+}
+
+void Mussa::set_dirty(bool new_state)
+{
+  if (dirty != new_state) {
+    dirty = new_state;
+    emit isModified(dirty);
+  }
 }
 
 bool Mussa::is_dirty() const
@@ -100,7 +114,7 @@ void
 Mussa::set_name(string a_name)
 {
   analysis_name = a_name;
-  dirty = true;
+  set_dirty(true);
 }
 
 string Mussa::get_name() const
@@ -133,7 +147,7 @@ void
 Mussa::set_window(int a_window)
 {
   window = a_window;
-  dirty = true;
+  set_dirty(true);
 }
 
 int Mussa::get_window() const
@@ -145,7 +159,7 @@ void
 Mussa::set_threshold(int a_threshold)
 {
   threshold = a_threshold;
-  dirty = true;
+  set_dirty(true);
   if (a_threshold > soft_thres) {
     soft_thres = a_threshold;
   }
@@ -177,7 +191,7 @@ void
 Mussa::set_analysis_mode(enum analysis_modes new_ana_mode)
 {
   ana_mode = new_ana_mode;
-  dirty = true;
+  set_dirty(true);
 }
 
 enum Mussa::analysis_modes Mussa::get_analysis_mode() const
@@ -304,17 +318,17 @@ void Mussa::append_sequence(const Sequence& a_seq)
 {
   boost::shared_ptr<Sequence> seq_copy(new Sequence(a_seq));
   the_seqs.push_back(seq_copy);
-  dirty = true;
+  set_dirty(true);
 }
 
 void Mussa::append_sequence(boost::shared_ptr<Sequence> a_seq)
 {
   the_seqs.push_back(a_seq);
-  dirty = true;
+  set_dirty(true);
 }
 
 
-const vector<boost::shared_ptr<Sequence> >& 
+const vector<SequenceRef>& 
 Mussa::sequences() const
 {
   return the_seqs;
@@ -333,7 +347,7 @@ void Mussa::load_sequence(fs::path seq_file, fs::path annot_file,
     aseq->set_species(*name);
   }
   the_seqs.push_back(aseq);
-  dirty = true;
+  set_dirty(true);
 }
 
 void
@@ -449,7 +463,7 @@ Mussa::load_mupa_file(fs::path para_file_path)
     //     << " threshold = " << threshold << endl;
   }
   // no file was loaded, signal error
-  dirty = true;
+  set_dirty(true);
 }
 
 
@@ -602,7 +616,7 @@ Mussa::save(fs::path save_path)
     }
   }
 
-  dirty = false;
+  set_dirty(false);
   analysis_path = save_path;
 }
 
@@ -625,10 +639,14 @@ Mussa::load(fs::path ana_file)
   vector<FLPs> empty_FLP_vector;
   FLPs dummy_comp;
 
+
+  //--------------------------------------------------------
+  // Load Muway
+  //--------------------------------------------------------
   analysis_path = ana_file;
   analysis_name = ana_path.leaf();
-  file_path_base =  ana_path.branch_path() / analysis_name;
-  a_file_path = file_path_base / (analysis_name + ".muway");
+  fs::path muway(analysis_name+".muway", fs::native);
+  a_file_path = analysis_path / muway;
   the_paths.load(a_file_path);
   // perhaps this could be more elegent, but at least this'll let
   // us know what our threshold and window sizes were when we load a muway
@@ -636,22 +654,63 @@ Mussa::load(fs::path ana_file)
   threshold = the_paths.get_threshold();
   soft_thres = threshold;
 
-  int seq_num = the_paths.sequence_count();
 
-  a_file_path = file_path_base / (analysis_name + ".museq");
+  //--------------------------------------------------------
+  // Load Sequence
+  //--------------------------------------------------------
+  //int seq_num = the_paths.sequence_count();
+
+  fs::path museq(analysis_name + ".museq", fs::native);
+  a_file_path = analysis_path / museq;
 
   // this is a bit of a hack due to C++ not acting like it should with files
-  for (i = 1; i <= seq_num; i++)
+  /*for (i = 1; i <= seq_num; i++)
   {
     boost::shared_ptr<Sequence> tmp_seq(new Sequence);
     tmp_seq->load_museq(a_file_path, i);
     the_seqs.push_back(tmp_seq);
+  }*/
+  
+  i = 1;
+  //int seq_num = 0;
+  boost::filesystem::fstream load_museq_fs;
+  load_museq_fs.open(a_file_path, std::ios::in);
+  boost::shared_ptr<Sequence> tmp_seq;
+  while (1)
+  {
+    tmp_seq = Sequence::load_museq(load_museq_fs);
+    
+    if (tmp_seq)
+    {
+      the_seqs.push_back(tmp_seq);
+    }
+    else
+    {
+      break;
+    }
+    
+    
+    //safe guard in case of an infinate loop.
+    //FIXME: If mussa can handle a comparison of 10000 sequences
+    // in the future, then this code should be fixed.
+    if (i == 10000)
+    {
+      throw mussa_load_error(" Run away sequence load!");
+    }
+    i++;
   }
+  load_museq_fs.close();
   
-  fs::path motif_file = file_path_base / (analysis_name + ".mtl");
+  //--------------------------------------------------------
+  // Load Motifs
+  //--------------------------------------------------------
+  fs::path mtl(analysis_name + ".mtl", fs::native);
+  fs::path motif_file = analysis_path / mtl;
   if (fs::exists(motif_file)) {
     load_motifs(motif_file);
   }
+  
+  vector<Sequence>::size_type seq_num = the_seqs.size();
   empty_FLP_vector.clear();
   for(i = 0; i < seq_num; i++)
   {
@@ -660,6 +719,7 @@ Mussa::load(fs::path ana_file)
       all_comps[i].push_back(dummy_comp);
   }
   
+  
   for(i = 0; i < seq_num; i++)
   {
     for(i2 = i+1; i2 < seq_num; i2++)
@@ -667,15 +727,13 @@ Mussa::load(fs::path ana_file)
       append_info.str("");
       append_info << analysis_name <<  "_sp_" << i << "v" << i2 << ".flp";
       //clog << append_info.str() << endl;
-      a_file_path = file_path_base / append_info.str();
-      //clog << "path " << a_file_path.string() << endl;
+      fs::path flp(append_info.str(), fs::native);
+      a_file_path = analysis_path / flp;
       all_comps[i][i2].load(a_file_path);
-      //clog << "real size = " << all_comps[i][i2].size() << endl;
     }
   }
 }
 
-
 void
 Mussa::save_old()
 {
@@ -752,7 +810,7 @@ void Mussa::add_motif(const Sequence& motif, const Color& color)
 {
   motif_sequences.insert(motif);
   color_mapper->appendInstanceColor("motif", motif.get_sequence(), color);
-  dirty = true;
+  set_dirty(true);
 }
 
 void Mussa::set_motifs(const vector<Sequence>& motifs, 
@@ -780,7 +838,7 @@ void Mussa::load_motifs(fs::path filename)
 void Mussa::load_motifs(std::istream &in)
 {
   std::string data;
-  const char *alphabet = Alphabet::nucleic_cstr;
+  const char *alphabet = Alphabet::dna_cstr;
   motif_parser::ParsedMotifs parsed_motifs(motif_sequences, color_mapper);
 
   // slurp our data into a string
@@ -821,7 +879,7 @@ void Mussa::update_sequences_motifs()
 {
   // once we've loaded all the motifs from the file, 
   // lets attach them to the sequences
-  for(vector<boost::shared_ptr<Sequence> >::iterator seq_i = the_seqs.begin();
+  for(vector<SequenceRef >::iterator seq_i = the_seqs.begin();
       seq_i != the_seqs.end();
       ++seq_i)
   {