Cassiopee.h

#include <iostream>
#include <fstream>
#include <list>
#include <map>
 
#include "tree/tree.hh"
 
#include "CassiopeeConfig.h"
 
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
// Provide an implementation of serialize for std::list
#include <boost/serialization/list.hpp>
 
using namespace std;
 
 
 
 
class Match {
public:
 
        bool operator==(const Match& p) const {
                return pos == p.pos && in+del == p.in + p.del;
        }
 
        int in;
        int del;
        int subst;
 
 
        long pos;
 
        Match();
 
 
};
 
class TreeNode {
public:
        char c;
 
 
        list<long> positions;
 
        long next_pos;
 
        long next_length;
 
 
        TreeNode(char nc);
 
        TreeNode(char nc, long pos);
        TreeNode();
 
 
private:
          friend class boost::serialization::access;
          template<class Archive>
          void serialize(Archive & ar, const unsigned int /*version*/)
          {
            ar & c;
            ar & next_pos;
            ar & next_length;
            ar & positions;
          }
 
};
 
 
 
#ifndef __CASSIOPEE_H_
#define __CASSIOPEE_H_
//inline std::ostream& operator<<(std::ostream &strm, const TreeNode &a) {
//  return strm << "TreeNode(" << a.c << ")";
//}
#endif
 
 
class CassieIndexer {
public:
 
 
        CassieIndexer(const char* path);
 
        ~CassieIndexer();
 
        void save();
 
        void load();
 
 
        void graph();
 
        void graph(int depth);
 
        string getSuffix(long pos);
 
        void index();
 
        tree<TreeNode>* getTree();
 
        list<Match> matches;
 
        bool do_reduction;
 
        char getCharAtSuffix(long pos);
 
        void filltree(long pos);
 
        long max_depth;
 
    long max_index_depth;
 
        long seq_length;
 
        bool index_loaded_from_file();
 
private:
        list<TreeNode> serialized_nodes;
 
        bool loaded_from_file;
 
        const char* filename;
        ifstream seqstream;
        tree<TreeNode> tr;
 
        const long MAX_SUFFIX;
        long suffix_position;
        char* suffix;
 
        long graphNode(tree<TreeNode>::iterator node, long counter, ofstream& myfile, int maxdepth);
 
        char* loadSuffix(long pos);
 
 
        void reset_suffix();
 
 
 
        void fillTreeWithSuffix(tree<TreeNode>::iterator sib, long suffix_pos, long pos);
        void fillTreeWithSuffix(long suffix_pos, long pos);
 
 
 
};
 
 
class CassiopeeUtils {
public:
        static void transform_fasta(const string in, const string out);
};
 
class Ambiguous {
public:
        static bool isequal(char a, char b);
private:
        static bool ismatchequal(char a, const char b[], int len);
        static const char K_MATCH[];
        static const char M_MATCH[];
        static const char R_MATCH[];
        static const char Y_MATCH[];
        static const char S_MATCH[];
        static const char W_MATCH[];
        static const char B_MATCH[];
        static const char V_MATCH[];
        static const char H_MATCH[];
        static const char D_MATCH[];
        static const char N_MATCH[];
};
 
 
struct per_position
{
    inline bool operator() (const Match* struct1, const Match* struct2)
    {
        return (struct1->pos < struct2->pos);
    }
};
 
class CassieSearch {
 
public:
        CassieSearch(CassieIndexer* index_ref);
 
        ~CassieSearch();
 
        void removeDuplicates();
 
        map<std::string, string> morphisms;
 
        Match* match_limits;
 
        list<Match*> matches;
 
        bool ambiguity;
 
        int nmax;
 
        int mode;
 
        void search(string suffix, bool clear);
 
 
        void search(string suffix);
 
        void search(string suffixes[]);
 
        bool isequal(char a,char b);
 
 
        int max_indel;
        int max_subst;
 
    long pattern_length;
 
        void sort();
 
private:
 
        static bool same_match (Match* first, Match* second)
        { return ( *first == *second ); }
 
        CassieIndexer* indexer;
 
        void getMatchesFromNode(tree<TreeNode>::iterator sib, const int nbSubst, const int nbIn, const int nbDel);
 
 
 
        void searchAtNode(string suffix, const long suffix_pos, const tree<TreeNode>::iterator root, int nbSubst, int nbIn, int nbDel, int nbN);
 
        void searchAtNode(string suffix, const long suffix_pos, const tree<TreeNode>::iterator root, const tree<TreeNode>::iterator start_node, int nbSubst, int nbIn, int nbDel, int nbN);
 
        bool searchAtreduction(const string suffix, const tree<TreeNode>::iterator sib, long counter, long tree_reducted_pos, int nbSubst, int nbIn, int nbDel, int nbN);
 
 
};