Seq.cc

/*

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/>.

*/

#include <cassert>
#include <algorithm>
#include <functional>
#include <Sequence/Seq.hpp>
#include <Sequence/SeqFunctors.hpp>

namespace Sequence
{
    Seq::Seq(void) : name{}, seq{}
    {
    }

    std::string
    Seq::substr(std::string::size_type beg, std::string::size_type len) const
    {
        return seq.substr(beg, len);
    }

    std::string
    Seq::substr(std::string::size_type beg) const
    {
        return seq.substr(beg);
    }

    Seq::size_type
    Seq::length(void) const
    {
        return seq.length();
    }

    Seq::size_type
    Seq::size(void) const
    {
        return seq.size();
    }

    Seq::reference Seq::operator[](const size_type &i)
    {
        assert(i < seq.length());
        return seq[i];
    }

    Seq::const_reference Seq::operator[](const size_type &i) const
    {
        assert(i < seq.length());
        return seq[i];
    }

    bool
    Seq::operator==(const Seq &rhs) const
    {
        return (this->seq == rhs.seq);
    }

    bool
    Seq::operator!=(const Seq &rhs) const
    {
        return (this->seq != rhs.seq);
    }

    Seq::operator std::string() const
    {
        return seq;
    }

    Seq::size_type
    Seq::UngappedLength(void) const
    {
        size_type ngap
            = size_type(std::count(seq.begin(), seq.end(), '-'));
        return (seq.length() - ngap);
    }

    bool
    Seq::IsGapped(void) const
    {
        return (seq.find('-') != std::string::npos);
    }

    void
    Seq::Subseq(const unsigned &beg, const unsigned &length)
    {
        assert(beg < seq.length() && (beg + length < seq.length()));
        seq.assign(seq.begin() + beg, seq.begin() + beg + length);
    }

    void
    Seq::Complement(void)
    {
        std::for_each(seq.begin(), seq.end(), ComplementBase());
    }

    void
    Seq::Revcom(void)
    {
        std::reverse(seq.begin(), seq.end());
        std::for_each(seq.begin(), seq.end(), ComplementBase());
    }

    Seq::iterator
    Seq::begin()
    {
        return seq.begin();
    }

    Seq::iterator
    Seq::end()
    {
        return seq.end();
    }

    Seq::const_iterator
    Seq::begin() const
    {
        return seq.begin();
    }

    Seq::const_iterator
    Seq::end() const
    {
        return seq.end();
    }

    Seq::const_iterator
    Seq::cbegin() const
    {
        return seq.cbegin();
    }

    Seq::const_iterator
    Seq::cend() const
    {
        return seq.cend();
    }

    const char *
    Seq::c_str(void) const
    {
        return seq.c_str();
    }

    //non-member functions
    std::ostream &
    operator<<(std::ostream &s, const Seq &c)
    {
        return c.print(s);
    }

    std::istream &
    operator>>(std::istream &s, Seq &c)
    {
        return c.read(s);
    }
} //ns Sequence