AlignStream.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 __ALIGNSTREAM_H__
#define __ALIGNSTREAM_H__

#include <Sequence/Alignment.hpp>
#include <Sequence/Seq.hpp>
#include <type_traits>
#include <utility>
#include <string>
#include <stdexcept>

namespace Sequence
  {
  template < typename T >
  class AlignStream
    {
    private:
      //only compile these templates with types in the class hierarchy of Sequence::Seq.  Allow pair<string,string>, too
      static_assert( std::is_same< std::pair<std::string,std::string >, T>::value ||
                     std::is_base_of< Sequence::Seq, T>::value ,
                     "T must be std::pair<std::string,std::string> or derived from Sequence::Seq");
                     
      std::vector < T >data;
    public:
      AlignStream(const std::vector<T> &  _data);
      AlignStream( std::vector<T> &&  _data);
      AlignStream(const AlignStream<T> &a);
      AlignStream( AlignStream<T> && a);
      AlignStream(void){}
      virtual ~ AlignStream (void);
      typedef typename std::vector<T>::size_type size_type;
      typedef typename std::vector<T>::reference reference;
      typedef typename std::vector<T>::const_reference const_reference;

      bool empty() const
      {
        return data.empty();
      }

      size_type size(void) const
        {
          return data.size();
        }

      reference operator[](const size_type & i) 
      
      {
        return data[i];
      }
      const_reference operator[](const size_type & i) const
      {
        return data[i];
      }
      typedef typename std::vector<T>::iterator iterator;
      typedef typename std::vector<T>::const_iterator const_iterator;
      iterator begin();
      iterator end();
      const_iterator begin() const;
      const_iterator end() const;
      bool IsAlignment (void);
      bool Gapped (void);
      unsigned UnGappedLength (void);
      void RemoveGaps (void);
      void RemoveTerminalGaps (void);
      std::vector < T >Trim ( std::vector < int >sites);
      std::vector < T >TrimComplement ( std::vector < int >sites);
      const std::vector< T > Data(void);
      virtual std::istream & read (std::istream & s) = 0;
      virtual std::ostream & print (std::ostream & s) const = 0;

      void assign(const_iterator beg,const_iterator end);
      void assign( std::vector<T> && _data);
    };


  template < typename T >
  std::istream & operator>> (std::istream & s, AlignStream < T > &c)
  {
    return c.read (s);
  }

  template < typename T >
  std::ostream & operator<< (std::ostream & s,const  AlignStream < T > &c)
  {
    return c.print (s);
  }

}
#include <Sequence/bits/AlignStream.tcc>
#endif