ppALIGN • 1.0

posterior probabilities for
score based sequence alignments

• Back

ppALIGN API documentation

src/sequence.hpp

/******************************************************************************
    Copyright 2009 Stefan Wolfsheimer & Gregory Nuel.

    This file is part of ppALIGN

    ppALIGN is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    ppALIGN is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with ppALIGN; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*******************************************************************************/

#ifndef _SEQUENCE_HPP_
#define _SEQUENCE_HPP_

#include "alphabet.hpp"

//
// class Sequence 
//

class Sequence : public std::vector<int> 
{
private:
  const Alphabet * alphabet;

public:

  typedef std::vector<int>                      parent_t;

  class ParseError : public ExceptionBase
  {
  public:
    ParseError(char ch, size_t line, size_t pos,const Alphabet & a);
    const char           ch;
    const size_t         pos;
    const size_t         line;
    const Alphabet & alphabet;
  };






  Sequence(const Alphabet & a) : 
    alphabet(&a) {}

  Sequence(const Sequence & seq) : 
    parent_t(seq),alphabet(seq.alphabet) { }

  
  Sequence(const Alphabet & a,
           const std::string & str) 
  : alphabet(&a)
  { *this+= str; }

  Sequence(const Alphabet & a,
           const_iterator begin,
           const_iterator end) : alphabet(&a)
  { resize(end-begin);
    for(const_iterator itr = begin; itr != end; ++itr) 
      this->operator[](itr-begin) = *itr;
  }


  Sequence(const Alphabet & a,
           const char * str) 
  : alphabet(&a)
  { *this+= str; }

  Sequence(const Alphabet & a,
           char  c) 
  : alphabet(&a)
  { *this+= c; }


  inline const Alphabet & GetAlphabet() const 
  { return *alphabet; }



  Sequence        & operator=(const char * str);
  inline Sequence & operator=(const std::string & str) 
  { clear(); *this = str.c_str(); return *this; }

  inline Sequence & operator=(const Sequence & seq) 
  { Alphabet::Match(*alphabet,*seq.alphabet); 
    clear(); 
    insert(begin(),seq.begin(),seq.end());  
    return *this; }


  Sequence & operator+= (const char * str);
  inline Sequence & operator+=  (const std::string & str) 
  { *this+= str.c_str(); 
    return *this; }

  inline Sequence & operator+=  (const Sequence & seq)    
  { 
    Alphabet::Match(*alphabet,*seq.alphabet); 
    insert(end(),seq.begin(),seq.end()); 
    return *this; }

  
  inline Sequence & operator+=  (const int i)             
  { push_back(i); return *this; }

  inline Sequence & operator+=  (const unsigned int i)    
  { push_back(i); return *this; }


  inline Sequence & operator+=  (const char ch)          
  { push_back(alphabet->ValidEncode(ch)); 
    return *this; }
  
  void Append(const char * str, int len);

  
  friend inline Sequence  operator + (const Sequence & a, const Sequence & b) 
  { Sequence tmp(a); tmp+= b;  return  tmp; }

  friend inline Sequence  operator + (char  a, const Sequence & b) 
  { Sequence tmp(*b.alphabet,a);  tmp+= b;   return tmp; }

  friend inline Sequence  operator + (const std::string & a,const Sequence & b) 
  { Sequence tmp(*b.alphabet,a); tmp+=b;  return tmp; }

  friend inline Sequence  operator + (int  a,               const Sequence & b) 
  { Sequence tmp(*b.alphabet,a); 
    return tmp; }

  friend inline Sequence  operator + (unsigned int a,       const Sequence & b) 
  { Sequence tmp(*b.alphabet,a); tmp+=b;
    return tmp; }

  friend inline Sequence  operator + (const Sequence & a, char  b)            
  { Sequence tmp(a); 
    tmp+=b;
    return tmp; }

  friend inline Sequence  operator + (const Sequence & a, const std::string & b)
  { Sequence tmp(a); 
    tmp+=b;
    return tmp; }

  friend inline Sequence  operator + (const Sequence & a,int b)               
  { Sequence tmp(a); 
    tmp+= b;
    return tmp; }

  friend inline Sequence  operator + (const Sequence & a, unsigned int  b)     
  { Sequence tmp(a); 
    tmp+= b;
    return tmp+=b; }

  friend inline bool  operator == (const Sequence & a,const Sequence & b)   
  { return parent_t(a)==parent_t(b);  }

  friend inline bool  operator == (char  a, const Sequence & b)     
  { return Sequence(*b.alphabet,a) == b; }

  friend inline bool  operator == (const std::string & a,const Sequence & b)     
  { return Sequence(*b.alphabet,a) == b; }

  friend inline bool  operator == (int  a,               const Sequence & b)     
  { return Sequence(*b.alphabet,a) == b; }

  friend inline bool  operator == (unsigned int a,       const Sequence & b)     
  { return Sequence(*b.alphabet,a) == b; }

  friend inline bool  operator == (const Sequence & a,   char  b)                
  { return a == Sequence(*a.alphabet,b); }

  friend inline bool  operator == (const Sequence & a,   const std::string & b)  
  { return a == Sequence(*a.alphabet,b); }

  friend inline bool  operator == (const Sequence & a,   int b)                  
  { return a == Sequence(*a.alphabet,b); }

  friend inline bool  operator == (const Sequence & a,   unsigned int  b)        
  { return a == Sequence(*a.alphabet,b); }

  friend inline bool  operator != (const Sequence & a,   const Sequence & b)     
  { return parent_t(a)!=parent_t(b); }

  friend inline bool  operator != (char  a,              const Sequence & b)     
  { return Sequence(*b.alphabet,a) != b; }

  friend inline bool  operator != (const std::string & a,const Sequence & b)     
  { return Sequence(*b.alphabet,a) != b; }

  friend inline bool  operator != (int  a,               const Sequence & b)     
  { return Sequence(*b.alphabet,a) != b; }

  friend inline bool  operator != (unsigned int a,       const Sequence & b)     
  { return Sequence(*b.alphabet,a) != b; }

  friend inline bool  operator != (const Sequence & a,   char  b)                
  { return a != Sequence(*a.alphabet,b); }

  friend inline bool  operator != (const Sequence & a,   const std::string & b)  
  { return a != Sequence(*a.alphabet,b); }

  friend inline bool  operator != (const Sequence & a,   int b)                  
  { return a != Sequence(*a.alphabet,b); }

  friend inline bool  operator != (const Sequence & a,   unsigned int  b)        
  { return a != Sequence(*a.alphabet,b); }


  inline Sequence & operator/= (int mask) 
  {
    Sequence v(*this);
    clear();
    for(iterator itr = v.begin(); itr != v.end(); ++itr) 
      {

        if(!alphabet->Probe(*itr,mask)) 
          {
            push_back(*itr);
          }
      }
    return *this;
  }

  Sequence operator/ (int mask) const
  {
    Sequence s(*alphabet);
    for(const_iterator itr = begin();
        itr != end(); 
        ++itr) 
      {
        if(!alphabet->Probe(*itr,mask)) 
          {
            s.push_back(*itr);
          }
      }
    return s;
  }

  bool CString(char * str, int max_length) const;




  friend std::ostream &  operator<<(std::ostream & ost, const Sequence & s) ;

  friend std::istream & operator>> (std::istream & ist, Sequence & s);

private:
  void Append(iterator & myitr,const char * tmp,size_t olds);

};


class DnaSequence : public Sequence
{
public:
  DnaSequence() : Sequence(dnaAlphabet) {} 
  DnaSequence(const Sequence & seq) : Sequence(seq) {}
  template<typename ITER>
  DnaSequence(const ITER & begin, 
              const ITER & end) : Sequence(dnaAlphabet,begin,end) {}

  template<typename ITER> 
  DnaSequence(const ITER & begin, 
              const ITER & end,
              bool validate) : Sequence(dnaAlphabet,begin,end,validate) {} 

  DnaSequence(const std::string & str) : Sequence(dnaAlphabet,str) {} 
  DnaSequence(const char * c) : Sequence(dnaAlphabet,c) {} 

  DnaSequence  & operator=(const std::string & str) { Sequence::operator=(str);  return *this; }
  DnaSequence  & operator=(const char  * str)       { Sequence::operator=(str);  return *this; }
  DnaSequence  & operator=(const Sequence & seq)    { Sequence::operator=(seq);  return *this; }

};


class ProteinSequence : public Sequence
{
public:
  ProteinSequence() : Sequence(proteinAlphabet) {} 
  ProteinSequence(const Sequence & seq) : Sequence(seq) {}
  template<typename ITER>
  ProteinSequence(const ITER & begin, 
                  const ITER & end) : Sequence(proteinAlphabet,begin,end) {}

  ProteinSequence(const std::string & str) : Sequence(proteinAlphabet,str) {} 
  ProteinSequence(const char  * str) : Sequence(proteinAlphabet,str) {} 
  ProteinSequence(const char & c) : Sequence(proteinAlphabet,c) {} 

  ProteinSequence  & operator=(const std::string & str) { Sequence::operator=(str);  return *this; }
  ProteinSequence  & operator=(const char  * str)       { Sequence::operator=(str);  return *this; }
  ProteinSequence  & operator=(const Sequence & seq)    { Sequence::operator=(seq);  return *this; }


};


#endif 

Design by 1234.info | Modified by Stefan Wolfsheimer | Powered by PHP | XHTML 1.0 | CSS 2.0