alignment.h

#include "../utils/timeutil.h"
#include "sequence.h"
 
#ifndef CMAPLE_ALIGNMENT_H
#define CMAPLE_ALIGNMENT_H
 
namespace cmaple {
class Alignment {
 public:
  enum InputType {
    IN_FASTA,   
    IN_PHYLIP,  
    IN_MAPLE,   
    IN_AUTO,    
    IN_UNKNOWN, 
  };
 
  // ----------------- BEGIN OF PUBLIC APIs ------------------------------------
  // //
  Alignment();
 
  Alignment(
      std::istream& aln_stream,
      const std::string& ref_seq = "",
      const InputType format = IN_AUTO,
      const cmaple::SeqRegion::SeqType seqtype = cmaple::SeqRegion::SEQ_AUTO);
 
  Alignment(
      const std::string& aln_filename,
      const std::string& ref_seq = "",
      const InputType format = IN_AUTO,
      const cmaple::SeqRegion::SeqType seqtype = cmaple::SeqRegion::SEQ_AUTO);
 
  ~Alignment();
 
  void read(
      std::istream& aln_stream,
      const std::string& ref_seq = "",
      const InputType format = IN_AUTO,
      const cmaple::SeqRegion::SeqType seqtype = cmaple::SeqRegion::SEQ_AUTO);
 
  void read(
      const std::string& aln_filename,
      const std::string& ref_seq = "",
      const InputType format = IN_AUTO,
      const cmaple::SeqRegion::SeqType seqtype = cmaple::SeqRegion::SEQ_AUTO);
 
  void write(std::ostream& aln_stream, const InputType& format = IN_MAPLE);
 
  void write(const std::string& aln_filename,
             const InputType& format = IN_MAPLE,
             const bool overwrite = false);
 
  // ----------------- END OF PUBLIC APIs ------------------------------------
  // //
 
  inline cmaple::SeqRegion::SeqType getSeqType() const { 
    return seq_type_; 
  }
 
  inline void setSeqType(cmaple::SeqRegion::SeqType seq_type) {
    seq_type_ = seq_type;
    updateNumStates();
  }
 
  auto readRefSeq(const std::string& ref_filename,
                         const std::string& ref_name) -> std::string;
 
  static char convertState2Char(const cmaple::StateType& state,
                                const cmaple::SeqRegion::SeqType& seqtype);
 
  static InputType parseAlnFormat(const std::string& n_format);
 
  std::vector<Sequence>
      data;  // note: this is inefficient, but only used briefly
 
  std::vector<cmaple::StateType> ref_seq;
 
  cmaple::StateType num_states;
 
  InputType aln_format = IN_AUTO;
 
  std::unordered_set<void*> attached_trees;
 
 private:
  cmaple::SeqRegion::SeqType seq_type_ = cmaple::SeqRegion::SEQ_AUTO;
 
  void reset();
 
  void updateNumStates();
 
  cmaple::SeqRegion::SeqType detectSequenceType(cmaple::StrVector& sequences);
 
  cmaple::PositionType computeSeqDistance(Sequence& sequence,
                                          cmaple::RealNumType hamming_weight);
 
  void sortSeqsByDistances();
 
  cmaple::StateType convertChar2State(char state);
 
  void extractMutations(const cmaple::StrVector& sequences,
                        const cmaple::StrVector& seq_names,
                        const std::string& ref_sequence);
 
  void readMaple(std::istream& aln_stream);
 
  void readFastaOrPhylip(std::istream& aln_stream,
                         const std::string& ref_seq = "");
 
  void parseRefSeq(std::string& ref_sequence);
 
  void readFasta(std::istream& aln_stream,
                 cmaple::StrVector& sequences,
                 cmaple::StrVector& seq_names,
                 bool check_min_seqs = true);
 
  void readPhylip(std::istream& aln_stream,
                  cmaple::StrVector& sequences,
                  cmaple::StrVector& seq_names,
                  bool check_min_seqs = true);
 
  void readSequences(std::istream& aln_stream,
                     cmaple::StrVector& sequences,
                     cmaple::StrVector& seq_names,
                     InputType aln_format = IN_AUTO,
                     bool check_min_seqs = true);
 
  std::string generateRef(cmaple::StrVector& sequences);
 
  void processSeq(std::string& sequence,
                  std::string& line,
                  cmaple::PositionType line_num);
 
  void addMutation(Sequence* sequence,
                   char state_char,
                   cmaple::PositionType pos,
                   cmaple::PositionType length = -1);
 
  void writeMAPLE(std::ostream& aln_stream);
 
  void writeFASTA(std::ostream& aln_stream);
 
  void writePHYLIP(std::ostream& aln_stream);
 
  auto getRefSeqStr() -> std::string;
 
  auto getSeqString(const std::string& ref_seq_str, Sequence* sequence) -> std::string;
 
  InputType detectMAPLEorFASTA(std::istream& aln_stream);
 
  InputType detectInputFile(std::istream& aln_stream);
    
};
 
auto operator<<(std::ostream& out_stream, cmaple::Alignment& aln) -> std::ostream&;
 
auto operator>>(std::istream& in_stream, cmaple::Alignment& aln) -> std::istream&;
 
extern char symbols_protein[];
extern char symbols_dna[];
extern char symbols_rna[];
extern char symbols_morph[];
}  // namespace cmaple
#endif