inventory.h

Go to the documentation of this file.

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


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

  inventory_t (std::pair<node_it,node_it>&& I) {
    clean();
    for (node_it i = I.first; i != I.second; i++) {
      for (ball_t *b : **i) {
        insert(b);              // 'insert' checks color
      }
    }
  };
  inventory_t (std::pair<node_it,node_it>&& I) {…}

  inventory_t (const inventory_t &) = default;
  inventory_t (inventory_t &&) = delete;
  inventory_t& operator= (std::pair<node_it,node_it>&& I) {
    clean();
    for (node_it i = I.first; i != I.second; i++) {
      for (ball_t *b : **i) {
        insert(b);              // 'insert' checks color
      }
    }
    return *this;
  };
  inventory_t& operator= (std::pair<node_it,node_it>&& I) {…}

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

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

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

  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>> (const inventory_t& I, raw_t* 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;
  };
  friend raw_t* operator>> (raw_t* o, inventory_t& I) {…}

  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 (void) const  {…}

  size_t size (name_t i) const {
    return _inven[i].size();
  };
  size_t size (name_t i) const  {…}

  pocket_t& operator[] (const name_t n) {
    return _inven[n];
  };
  pocket_t& operator[] (const name_t n) {…}

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

  ball_t* random_ball (name_t i = 0) 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;
  };
  ball_t* random_ball (name_t i = 0) const  {…}

  pocket_t* random_balls (name_t i = 0, 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;
  };
  pocket_t* random_balls (name_t i = 0, int n = 1) const  {…}

  void insert (ball_t *b) {
    if (b->is(black)) {
      _inven[b->deme()].insert(b);
    }
  };
  void insert (ball_t *b) {…}

  void erase (ball_t *b) {
    if (b->is(black)) {
      assert(!(_inven[b->deme()].empty()));
      _inven[b->deme()].erase(b);
    }
  };
  void erase (ball_t *b) {…}
};
class inventory_t {…};
 
#endif