master.h

Go to the documentation of this file.

// -*- C++ -*-
 
#ifndef _MASTER_H_
#define _MASTER_H_
 
#include "popul_proc.h"
#include "genealogy.h"
#include "inventory.h"
#include "internal.h"


template <class POPN, size_t NDEME>
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 geneal.bytesize() + popul_t::bytesize();
  };

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

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

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

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

  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 (master_t &&) = default;
  master_t & operator= (master_t &&) = default;
  ~master_t (void) {
    clean();
  };

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

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

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

  string_t newick (void) const {
    return geneal.newick();
  };

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

  SEXP structure (void) const {
    return geneal.structure();
  };
 
public:
  void birth (name_t i = 1, name_t j = 1, 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 death (name_t i = 1) {
    ball_t *a = inventory.random_ball(i);
    inventory.erase(a);
    geneal.death(a,time());
  };

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

  void sample (name_t i = 1, 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_death (name_t i = 1, 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 migrate (name_t i = 1, name_t j = 1) {
    ball_t *a = inventory.random_ball(i);
    inventory.erase(a);
    geneal.migrate(a,time(),j);
    inventory.insert(a);
  };

  void sample_migrate (name_t i = 1, name_t j = 1) {
    ball_t *a = inventory.random_ball(i);
    inventory.erase(a);
    geneal.sample_migrate(a,time(),j);
    inventory.insert(a);
  };

  void rinit (void);
  void jump (int e);
};
 
#endif