SimTypes.hpp

Go to the documentation of this file.

#ifndef __SEQUENCE_COALESCENT_SIM_TYPES_HPP__
#define __SEQUENCE_COALESCENT_SIM_TYPES_HPP__

#include <vector>
#include <list>
#include <iosfwd>
#include <cassert>
#include <memory>

namespace Sequence
{
  namespace coalsim {
    struct segment
    {
      int beg,end,desc;
      segment();
      explicit segment(const int & b,
                       const int & e,
                       const int & d);
    };

    struct chromosome
    {
      segment * segs;
      typedef segment * iterator;
      typedef const segment * const_iterator;
      int pop;
      unsigned nsegs;
      chromosome();
      chromosome(const chromosome & ch);
      chromosome( const std::vector<segment> & initial_segs,
                  const int & population = 0 );
      ~chromosome();
      chromosome & operator=(const chromosome & ch);
      void swap_with( chromosome & ch );
      void assign_allocated_segs( segment * newsegs,
                                  const unsigned & new_nsegs );
      int first() const
      {
        assert(nsegs>0);
        return segs->beg;
      }

      int last() const
      {
        assert(nsegs>0);
        return (segs+nsegs-1)->end;
      }
      int links() const;
      iterator begin();
      iterator end();
      const_iterator begin() const;
      const_iterator end() const;
    };

    std::ostream & operator<<(std::ostream & s,const  chromosome & c);

    struct node
    {
      double time;
      int abv;
      node(const double & t = 0.,
           const int & a = -1 );
    };

    struct marginal
    {
      int beg;
      const int nsam;
      int nnodes;
      std::vector<node> tree;
      typedef std::vector<node>::iterator iterator;
      typedef std::vector<node>::const_iterator const_iterator;
      typedef std::vector<node>::size_type size_type;
      typedef std::vector<node>::reference reference;
      typedef std::vector<node>::const_reference const_reference;
      iterator begin();
      iterator end();
      const_iterator begin() const;
      const_iterator end() const;
      reference operator[](const std::vector<node>::size_type &i);
      const_reference operator[](const std::vector<node>::size_type &i) const;
      marginal(const int & b, const int & ns,const int & nn, 
               const std::vector<node> & tree);
      bool operator<(const marginal & rhs) const;
    };

    typedef std::list<marginal> arg;
    std::ostream & operator<<(std::ostream & s, const marginal & m);

    class newick_stream_marginal_tree_impl;
    class newick_stream_marginal_tree
    {
    private:
      std::unique_ptr<newick_stream_marginal_tree_impl> impl;
    public:
      newick_stream_marginal_tree( const marginal & m );
      newick_stream_marginal_tree( const marginal * m );
      newick_stream_marginal_tree( arg::const_iterator m );
      newick_stream_marginal_tree( arg::iterator m );
      ~newick_stream_marginal_tree( );
      std::vector<node> get_tree() const;
      std::ostream & print( std::ostream & o ) const;
      std::istream & read( std::istream & i );
    };
    std::ostream & operator<<(std::ostream & o, const newick_stream_marginal_tree & n);
    std::istream & operator>>(std::istream & i, newick_stream_marginal_tree & n);
  }
}
#endif