PolyTable.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 POLYTABLE_H
#define POLYTABLE_H

#include <string>
#include <vector>
#include <cassert>
#include <iosfwd>
#include <exception>
#include <boost/type_traits.hpp>
#include <boost/static_assert.hpp>
#include <Sequence/SeqExceptions.hpp>
#include <Sequence/PolyTableManip.hpp>

namespace Sequence
{
  class PolyTable
  {
  private:
    std::vector<double> positions;
    std::vector<std::string> data;
    mutable Sequence::polySiteVector pv;
    mutable bool non_const_access;
  public:
    //typedefs for container types
    typedef std::string & reference;
    typedef const std::string & const_reference;
    typedef std::vector<std::string>::size_type size_type;

    typedef std::vector<std::string>::iterator data_iterator;
    typedef std::vector<std::string>::const_iterator const_data_iterator;
    typedef std::vector<double>::iterator pos_iterator;
    typedef std::vector<double>::const_iterator const_pos_iterator;
    typedef Sequence::polySiteVector::const_iterator const_site_iterator;

    //functions to return iterators
    data_iterator begin();
    data_iterator end();
    const_data_iterator begin() const;
    const_data_iterator end() const;
    pos_iterator pbegin();
    pos_iterator pend();
    const_pos_iterator pbegin() const;
    const_pos_iterator pend() const;
    const_site_iterator sbegin() const;
    const_site_iterator send() const;

    //constructor types
    explicit PolyTable(const size_t & nsam = 0, const size_t nsnps = 0);   
    explicit PolyTable(PolyTable::const_site_iterator beg,
                       PolyTable::const_site_iterator end);
    virtual ~ PolyTable (void);

    
    std::vector < double > GetPositions (void) const;
    std::vector < std::string > GetData (void) const;

    //operations on the data (non-const)
    virtual void ApplyFreqFilter(unsigned mincount,bool haveOutgroup=false,
                                 unsigned outgroup = 0);
    virtual void RemoveMultiHits(bool skipOutgroup=false,
                                 unsigned outgroup=0);
    virtual void RemoveMissing(bool skipOutgroup=false,
                               unsigned outgroup=0);
    virtual void RemoveAmbiguous(bool skipOutgroup=false,
                                 unsigned outgroup=0);
    virtual void Binary (bool haveOutgroup = false,
                         unsigned outgroup = 0,
                 bool strictInfSites = true);

    //operators and implicit typecasts
    virtual bool operator==(const PolyTable &rhs) const;
    virtual bool operator!=(const PolyTable &rhs) const;
    operator Sequence::polySiteVector() const;

    //The functions below are inlined data access routines.
    inline const_reference operator[] (const size_type & i) const
    {
      assert(i<data.size());
      return (data[i]);
    }

    inline reference operator[] (const size_type & i)
    {
      assert(i<data.size());
      non_const_access=true;
      return (data[i]);
    }
    bool empty() const;
    
    bool assign(PolyTable::const_site_iterator beg,
                PolyTable::const_site_iterator end);
    template<typename numeric_type,
             typename string_type>
    bool assign( const numeric_type * _positions, 
                 const size_t & _num_positions,
                 const string_type * _data,
                 const size_t & _num_individuals );

//     template<typename iterator>
//     bool rear_insert( const iterator beg,
//                    const iterator end );

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

    inline double position (const std::vector<double>::size_type & i) const
    {
      assert( i < positions.size());
      return positions[i];
    }

    inline unsigned numsites (void) const
    {
      return unsigned(positions.size());
    }

    virtual std::istream & read(std::istream &h) 
      throw (Sequence::badFormat,std::exception) =0;

    virtual std::ostream & print(std::ostream &h) const =0 ;
  };

  inline std::istream & operator>> (std::istream & s, PolyTable & c)
  {
    return c.read (s);
  }

  inline std::ostream & operator<< (std::ostream & o, const PolyTable & c)
  {
    return c.print (o);
  }

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

---