shortestPath.hpp

Go to the documentation of this file.

/*

Copyright (C) 2003-2009 Kevin Thornton, krthornt[]@[]uci.edu

Remove the brackets to email me.

This file is part of libsequence.

libsequence 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 3 of the License, or
(at your option) any later version.

libsequence 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
long with libsequence.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef __SHORTEST_PATH_HPP__
#define __SHORTEST_PATH_HPP__
#include <vector>
#include <utility>
#include <memory>
#include <Sequence/SeqEnums.hpp>
#include <Sequence/SeqExceptions.hpp>
#include <boost/tuple/tuple.hpp>
namespace Sequence
{
  class shortestPathImpl;
  class shortestPath 
  {
  private:
    std::auto_ptr<shortestPathImpl> impl;
  public:
    enum pathType {S,N,SS,SN,NN,SSS,SSN,SNN,NNN,NONE,AMBIG};

    explicit shortestPath(const std::string &codon1,
                          const std::string &codon2,
                          const Sequence::GeneticCodes & code = Sequence::UNIVERSAL) 
      throw (Sequence::SeqException);
    ~shortestPath();
    pathType type() const;
    double path_distance() const;
    typedef std::vector<std::string>::const_iterator const_iterator;
    const_iterator begin() const;
    const_iterator end() const;
  };

  std::pair<unsigned,unsigned> mutsShortestPath(const std::string &codon1,
                                                const std::string &codon2,
                                                const Sequence::GeneticCodes 
                                                & code = Sequence::UNIVERSAL)
    throw (Sequence::SeqException);

  std::pair<unsigned,shortestPath::pathType> diffType(const std::string &codon1,
                                                      const std::string &codon2,
                                                      const Sequence::GeneticCodes 
                                                      & code = Sequence::UNIVERSAL)
    throw (Sequence::SeqException);

  boost::tuple<shortestPath::pathType,shortestPath::pathType,shortestPath::pathType>
  diffTypeMulti(const std::string &codon1,
                const std::string &codon2,
                const Sequence::GeneticCodes 
                & code = Sequence::UNIVERSAL)
    throw (Sequence::SeqException);
}
#endif

---