PolySites.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 <Sequence/PolySites.hpp>
#include <Sequence/Fasta.hpp>
#include <sstream>
#include <iterator>
#include <algorithm>
#include <iostream>

namespace Sequence
{
  PolySites::PolySites (void) : PolyTable()
  {}

  
  // PolySites::PolySites (const std::vector < double > &List, const std::vector <std::string > &stringList):
  //   PolyTable(List,stringList)
  //   /*!
  //     Use this constructor if you already have a list of positions and characters
  //     \param List a list of doubles representing positions of polymorphic positions
  //     \param stringList a vector of strings representing the polymorphic characters
  //   */
  // {
  // }
  
  PolySites::PolySites ( std::vector < double > List, std::vector < std::string > stringList) :
    PolyTable(std::move(List),std::move(stringList))
  {
  }

  PolySites::PolySites (PolyTable::const_site_iterator beg,
                        PolyTable::const_site_iterator end):
    PolyTable(beg,end)
  {
  }

  PolySites::PolySites( PolySites && pt ) : PolyTable(std::move(pt))
  {
  }

  PolySites::PolySites(const PolySites & rhs) : PolyTable(rhs)
  {
  }

  PolySites & PolySites::operator=(PolySites && pt)
  {
    PolyTable::operator=(std::move(pt));
    return *this;
  }

  PolySites & PolySites::operator=(const PolySites & pt)
  {
    PolyTable::operator=(pt);
    return *this;
  }

  std::istream & PolySites::read(std::istream &s) 
  {
    std::vector<double> _pos;
    std::vector<std::string> _ind;
    std::string temp;
    //get positions--which is the first line of input
    std::getline(s,temp);
    std::istringstream i(temp);
    std::copy(std::istream_iterator<double>(i),std::istream_iterator<double>(),
              std::back_inserter(_pos));

    while (std::getline(s,temp))
      {
        std::string temp2;
        std::istringstream i(temp);
        std::copy(std::istream_iterator<char>(i),std::istream_iterator<char>(),
                  std::back_inserter(temp2));
        _ind.push_back(temp2);
      }
    if (! assign( std::move(_pos), std::move(_ind) ) )
      {
        throw std::runtime_error("PolySites::read() -- format error, unable to assign data");
      }
    return s;
  }

  std::ostream & PolySites::print(std::ostream &stream) const
  {
    for(unsigned i = 0 ; i < this->numsites() ; ++i)
      {
        if(i==0)
          stream << this->position(i);
        else
          stream << '\t' << this->position(i);
      }
    stream << '\n';

    for(unsigned i = 0 ; i < this->size() ; ++i)
      {
        for(unsigned j = 0 ; j < this->numsites() ; ++j)
          {
            if(j==0)
              stream << (*this)[i][j];
            else
              stream << '\t'<<(*this)[i][j];
          }
        if(i < this->size()-1)
          stream << '\n';
      }
    return (stream);
  }
}