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
{
  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 int & 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;
    mutable 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:
    newick_stream_marginal_tree_impl * impl;
    /*
    marginal::const_iterator mi;
    const int nsam;
    std::vector<int> left,right;
    std::vector<node> tree;
    void init();
    std::ostream & parens( const int & noden,
                           std::ostream & o) const;
    */
  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

---