inventory.h

Go to the documentation of this file.

// -*- C++ -*-
// INVENTORY CLASS
 
#ifndef _INVENTORY_H_
#define _INVENTORY_H_
 
#include "ball.h"
#include "pocket.h"
#include "node.h"
#include "genealogy.h"
#include "internal.h"


template <size_t NDEME>
class inventory_t {
 
private:
 
  const static size_t ndeme = NDEME;
  pocket_t _inven[ndeme];
 
public:
 
  // CONSTRUCTORS, DESTRUCTORS, ETC.
  inventory_t (void) = default;
  inventory_t (raw_t *o) {
    o >> *this;
  };

  inventory_t (const inventory_t &) = default;
  inventory_t (inventory_t &&) = delete;
  inventory_t (const genealogy_t& G) {
    assert(G.ndeme()==ndeme);
    clean();
    for (node_t *p : G) {
      for (ball_t *b : *p) {
        insert(b);              // 'insert' checks color
      }
    }
  };

  inventory_t & operator= (const genealogy_t& G) {
    assert(G.ndeme()==ndeme);
    clean();
    for (node_t *p : G) {
      for (ball_t *b : *p) {
        insert(b);              // 'insert' checks color
      }
    }
    return *this;
  };

  inventory_t & operator= (const inventory_t &) = default;
  inventory_t & operator= (inventory_t &&) = delete;
  ~inventory_t (void) {
    clean();
  };
 
private:

  void clean (void) {
    clear();
  };

  void clear (void) {
    for (size_t i = 0; i < ndeme; i++)
      _inven[i].clear();
  };
 
public:
 
  // SERIALIZATION
  size_t bytesize (void) const {
    size_t s = 0;
    for (size_t i = 0; i < ndeme; i++)
      s += _inven[i].bytesize();
    return s;
  };

  friend raw_t* operator>> (const inventory_t& I, raw_t* o) {
    for (size_t i = 0; i < ndeme; i++) {
      o = (I._inven[i] >> o);
    }
    return o;
  };

  friend raw_t* operator>> (raw_t* o, inventory_t& I) {
    I.clean();
    for (size_t i = 0; i < ndeme; i++) {
      o = (o >> I._inven[i]);
    }
    return o;
  };
 
public:

  size_t size (void) const {
    size_t n = 0;
    for (name_t i = 0; i < ndeme; i++) {
      n += size(i);
    }
    return n;
  };

  size_t size (name_t i) const {
    return inven(i).size();
  };

  const pocket_t& operator[] (const name_t i) const {
    return inven(i);
  };

  pocket_t& operator[] (const name_t i) {
    return inven(i);
  };
 
private:

  const pocket_t& inven (const name_t i) const {
    assert(i > 0);
    return _inven[i-1];
  };

  pocket_t& inven (const name_t i) {
    assert(i > 0);
    return _inven[i-1];
  };
 
public:

  void insert (ball_t *b) {
    if (b->is(black)) {
      inven(b->deme()).insert(b);
    }
  };

  void erase (ball_t *b) {
    if (b->is(black)) {
      assert(!inven(b->deme()).empty());
      inven(b->deme()).erase(b);
    }
  };

  bool empty (void) const {
    bool q = true;
    for (name_t i = 0; i < ndeme; i++) {
      q = q && _inven[i].empty();
    }
    return q;
  };

  ball_t* random_ball (name_t i) const {
    name_t n = inven(i).size();
    assert(n > 0);
    name_t draw = random_integer(n);
    ball_it k = inven(i).begin();
    while (draw-- > 0) k++;
    return *k;
  };

  pocket_t* random_balls (name_t i, int n = 1) const {
    pocket_t *p = new pocket_t();
    if (n == 1) {
      ball_t *b = random_ball(i);
      p->insert(b);
    } else if (n > 1) {
      int N = inven(i).size();
      assert(N > 0);
      assert(n <= N);
      ball_it j = inven(i).begin();
      int k = 0, m = 0;
      while (m < n && k < N) {
        int u = random_integer(N-k);
        if (u < n-m) {
          p->insert(*j);
          m++;
        }
        k++; j++;
      }
    } else {
      assert(0);                // #nocov
    }
    return p;
  };
};
 
#endif