master.h

Go to the documentation of this file.

// -*- C++ -*-
 
#ifndef _MASTER_H_
#define _MASTER_H_
 
#include <string>
#include <cstring>
#include "popul_proc.h"
#include "genealogy.h"
#include "internal.h"


template <class POPN, size_t NDEME = 1>
class master_t : public POPN {
 
public:
 
  typedef POPN popul_t;
  const static size_t ndeme = NDEME;
 
public:
  // DATA MEMBERS
  genealogy_t geneal;
  inventory_t<ndeme> inventory;
 
public:
  size_t bytesize (void) const {
    return popul_t::bytesize() + geneal.bytesize();
  };
  size_t bytesize (void) const  {…}

  friend raw_t* operator>> (const master_t& A, raw_t* o) {
    o = (reinterpret_cast<const popul_t&>(A) >> o);
    o = (A.geneal >> o);
    return o;
  }
  friend raw_t* operator>> (const master_t& A, raw_t* o) {…}

  friend raw_t* operator>> (raw_t* o, master_t& A) {
    A.clean();
    o = (o >> reinterpret_cast<popul_t&>(A));
    o = (o >> A.geneal);
    A.inventory = A.geneal.extant();
    return o;
  }
  friend raw_t* operator>> (raw_t* o, master_t& A) {…}
 
private:
 
  void clean (void) { };
 
public:
  // CONSTRUCTORS, ETC.
  master_t (double t0 = 0) : popul_t(t0), geneal(t0,0,ndeme) {};
  master_t (raw_t *o) {
    o >> *this;
  };
  master_t (raw_t *o) {…}

  master_t (SEXP o) {
    if (LENGTH(o)==0)
      err("in %s (%s line %d): cannot deserialize a NULL.",
          __func__,__FILE__,__LINE__);
    PROTECT(o = AS_RAW(o));
    RAW(o) >> *this;
    UNPROTECT(1);
  };
  master_t (SEXP o) {…}

  master_t (const master_t& A) {
    raw_t *o = new raw_t[A.bytesize()];
    A >> o;
    o >> *this;
    delete[] o;
  };
  master_t (const master_t& A) {…}

  master_t & operator= (const master_t& A) {
    clean();
    raw_t *o = new raw_t[A.bytesize()];
    A >> o;
    o >> *this;
    delete[] o;
    return *this;
  };
  master_t & operator= (const master_t& A) {…}

  master_t (master_t &&) = default;
  master_t & operator= (master_t &&) = default;
  ~master_t (void) {
    clean();
  };
  ~master_t (void) {…}

  slate_t timezero (void) const {
    return geneal.timezero();
  };
  slate_t timezero (void) const  {…}

  int play (double tfin) {
    int count = popul_t::play(tfin);
    geneal.time() = tfin;
    return count;
  };
  int play (double tfin) {…}
 
public:
  slate_t time (void) const {
    return popul_t::time();
  };
  slate_t time (void) const  {…}

  std::string describe (void) const {
    return geneal.describe();
  };
  std::string describe (void) const  {…}

  std::string yaml (std::string tab = "") const {
    std::string t = tab + "  ";
    std::string s = popul_t::yaml(tab)
      + "genealogy:\n" + geneal.yaml(t);
    return s;
  };
  std::string yaml (std::string tab = "") const  {…}

  std::string newick (void) const {
    return geneal.newick();
  };
  std::string newick (void) const  {…}

  SEXP lineage_count (void) const {
    return geneal.lineage_count();
  };
  SEXP lineage_count (void) const  {…}

  SEXP structure (void) const {
    return geneal.structure();
  };
  SEXP structure (void) const  {…}
 
public:
  void birth (name_t i = 0, name_t j = 0, int n = 1) {
    ball_t *a = inventory.random_ball(i);
    ball_t *b = geneal.birth(a,time(),j);
    inventory.insert(b);
    while (n > 1) {
      b = geneal.birth(b->holder(),j);
      inventory.insert(b);
      n--;
    }
  };
  void birth (name_t i = 0, name_t j = 0, int n = 1) {…}

  void death (name_t i = 0) {
    ball_t *a = inventory.random_ball(i);
    inventory.erase(a);
    geneal.death(a,time());
  };
  void death (name_t i = 0) {…}

  void graft (name_t i = 0, int m = 1) {
    for (int j = 0; j < m; j++) {
      ball_t *a = geneal.graft(time(),i);
      inventory.insert(a);
    }
  };
  void graft (name_t i = 0, int m = 1) {…}

  void sample (name_t i = 0, int n = 1) {
    pocket_t *p = inventory.random_balls(i,n);
    for (ball_t *a : *p) {
      geneal.sample(a,time());
    }
    p->clear();
    delete p;
  };
  void sample (name_t i = 0, int n = 1) {…}

  void sample_death (name_t i = 0, int n = 1) {
    pocket_t *p = inventory.random_balls(i,n);
    for (ball_t *a : *p) {
      inventory.erase(a);
      geneal.sample_death(a,time());
    }
    p->clear();
    delete p;
  };
  void sample_death (name_t i = 0, int n = 1) {…}

  void migrate (name_t i = 0, name_t j = 0) {
    ball_t *a = inventory.random_ball(i);
    inventory.erase(a);
    geneal.migrate(a,time(),j);
    a->deme() = j;
    inventory.insert(a);
  };
  void migrate (name_t i = 0, name_t j = 0) {…}

  void rinit (void);
  void jump (int e);
};
class master_t : public POPN {…};
 
#endif