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 <Sequence/Seq.hpp>
#include <Sequence/SeqFunctors.hpp>

namespace Sequence
{
  Seq::Seq (void) : SeqBase()
  {
  }
  
  Seq::Seq (const char *name, const char *seq): SeqBase(name,seq)
  {
  }
  
  Seq::Seq (const Seq & seq) : SeqBase(seq.first,seq.second) {}

  std::string Seq::GetName (void) const
  {
    return first;
  }

  std::string Seq::GetSeq (void) const
  {
    return second;
  }

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

  std::string Seq::substr(unsigned beg) const
  {
    return second.substr(beg);
  }

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

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

  Seq::const_reference
  Seq::operator[] (const size_type & i) const
  {
    assert(i < second.length ());
    return second[i];
  }
  
  bool Seq::operator==(const Seq & rhs) const
  {
    return (this->second==rhs.second);
  }

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

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

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

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

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

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

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

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

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

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

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

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

---