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 <type_traits>
#include <functional>
#include <memory>
#include <Sequence/polySiteVector.hpp>
namespace Sequence
{
    class __attribute__((deprecated)) PolyTable
    {
      private:
        struct PolyTableImpl;
        std::unique_ptr<PolyTableImpl> impl;

      public:
        using pos_container_t = std::vector<double>;
        using geno_container_t = std::vector<std::string>;

        //typedefs for container types
        using reference = geno_container_t::reference;
        using const_reference = geno_container_t::const_reference;
        using size_type = geno_container_t::size_type;
        using data_iterator = geno_container_t::iterator;
        using const_data_iterator = geno_container_t::const_iterator;
        using pos_iterator = std::vector<double>::iterator;
        using const_pos_iterator = std::vector<double>::const_iterator;
        using const_site_iterator = Sequence::polySiteVector::const_iterator;
        using row_t = geno_container_t::value_type;
        using column_t = const_site_iterator::value_type;
        //functions to return iterators
        data_iterator begin();
        data_iterator end();
        const_data_iterator begin() const;
        const_data_iterator end() const;
        const_data_iterator cbegin() const;
        const_data_iterator cend() const;
        pos_iterator pbegin();
        pos_iterator pend();
        const_pos_iterator pbegin() const;
        const_pos_iterator pend() const;
        const_pos_iterator pcbegin() const;
        const_pos_iterator pcend() const;
        const_site_iterator sbegin() const;
        const_site_iterator send() const;
        const_site_iterator scbegin() const;
        const_site_iterator scend() const;

        //constructor types
        explicit PolyTable();
        explicit PolyTable(PolyTable::const_site_iterator beg,
                           PolyTable::const_site_iterator end);
        explicit PolyTable(std::vector<double> __positions,
                           std::vector<std::string> __data);
        PolyTable(PolyTable &&);
        PolyTable(const PolyTable &);
        virtual ~PolyTable(void);

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

        //operators and implicit typecasts

        virtual bool operator==(const PolyTable &rhs) const;
        virtual bool operator!=(const PolyTable &rhs) const;
        PolyTable &operator=(PolyTable &&);
        PolyTable &operator=(const PolyTable &);
        const_reference operator[](const size_type &i) const;
        reference operator[](const size_type &i);

        bool empty() const;

        bool assign(PolyTable::const_site_iterator beg,
                    PolyTable::const_site_iterator end);

        //Swap data with another PolyTable
        void swap(PolyTable &);
        bool assign(const std::vector<double> &__positions,
                    const std::vector<std::string> &__data);
        bool assign(std::vector<double> &&__positions,
                    std::vector<std::string> &&__data);

        size_type size(void) const;

        double position(const std::vector<double>::size_type &i) const;

        unsigned numsites(void) const;

        virtual std::istream &read(std::istream &h) = 0;

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

    std::istream &operator>>(std::istream &s, PolyTable &c);

    std::ostream &operator<<(std::ostream &o, const PolyTable &c);
}
#endif