node.h

Go to the documentation of this file.

// -*- C++ -*-
// NODE CLASS
 
#ifndef _NODE_H_
#define _NODE_H_
 
#include <unordered_map>
#include <vector>
#include "ball.h"
#include "pocket.h"
#include "internal.h"
 
static const name_t null_lineage = name_t(NA_INTEGER);


class node_t : public pocket_t {
 
private:
 
  ball_t *_green_ball;
  name_t _lineage;
 
  void clean (void) { };
 
public:
 
  name_t uniq;
  slate_t slate;
 
public:

  size_t bytesize (void) const {
    return 2*sizeof(name_t) + sizeof(slate_t)
      + pocket_t::bytesize();
  };

  friend raw_t* operator>> (const node_t &p, raw_t *o) {
    name_t buf[2] = {p.uniq, p._lineage};
    memcpy(o,buf,sizeof(buf)); o += sizeof(buf);
    memcpy(o,&p.slate,sizeof(slate_t)); o += sizeof(slate_t);
    return reinterpret_cast<const pocket_t&>(p) >> o;
  };

  friend raw_t* operator>> (raw_t *o, node_t &p) {
    p.clean();
    name_t buf[2];
    memcpy(buf,o,sizeof(buf)); o += sizeof(buf);
    memcpy(&p.slate,o,sizeof(slate_t)); o += sizeof(slate_t);
    p.uniq = buf[0]; p._lineage = buf[1];
    o = (o >> reinterpret_cast<pocket_t&>(p));
    p.repair_holder(&p);
    return o;
  };
 
  void reuniqify (name_t shift);
 
public:

  node_t (name_t u = 0, slate_t t = R_NaReal) {
    uniq = u;
    slate = t;
    _green_ball = 0;
    _lineage = null_lineage;
  };

  node_t (const node_t &p) = delete;
  node_t (node_t && p) = delete;
  node_t & operator= (const node_t & p) = delete;
  node_t & operator= (node_t && p) = delete;
  ~node_t (void) {
    clean();
  };
 
public:

  ball_t* green_ball (void) const {
    return _green_ball;
  };

  ball_t*& green_ball (void) {
    return _green_ball;
  };

  name_t deme (void) const {
    return _green_ball->deme();
  };

  name_t& deme (void) {
    return _green_ball->deme();
  };

  name_t lineage (void) const {
    return _lineage;
  };

  name_t lineage (const ball_t *g) const {
    return g->owner()->lineage();
  };

  name_t& lineage (void) {
    return _lineage;
  };
  node_t* parent (void) const {
    return _green_ball->holder();
  };
  bool is_root (void) const {
    return (_green_ball->holder() == this);
  };
  bool dead_root (void) const {
    return is_root() && size()==1;
  };
 
public:

  int nchildren (void) const {
    int n = 0;
    for (ball_t *b : *this) {
      switch (b->color) {
      case green: case black:
        n++;
        break;
      default:
        break;
      }
    }
    if (is_root()) n--;
    return n;
  };

  void lineage_incr (int *incr, int *sat, int *etype) const;

  slate_t joining_branch_length (const std::unordered_map<name_t, bool>&) const;

  void cblv (std::vector<slate_t>&, std::vector<slate_t>&,
             std::unordered_map<name_t, bool>&,
             const std::unordered_map<name_t,std::vector<node_t*>>&,
             slate_t) const;
 
public:

  void insert (ball_t *a) {
    a->holder() = this;
    pocket_t::insert(a);
  };

  string_t yaml (string_t tab = "") const;
  SEXP structure (void) const;
  string_t newick (const slate_t& tnow, const slate_t& tpar,
                   bool showdeme, bool extended) const;
 
};
 
#endif