pocket.h

Go to the documentation of this file.

// -*- C++ -*-
// The POCKET class
 
#ifndef _POCKET_H_
#define _POCKET_H_
 
#include <set>
#include <unordered_map>
#include <string>
#include <cstring>
#include "ball.h"
#include "internal.h"


struct ball_order {
  bool operator() (const ball_t* a, const ball_t* b) const {
    return (a->color < b->color) ||
      ((a->color == b->color) && (a->uniq < b->uniq));
  };
  bool operator() (const ball_t* a, const ball_t* b) const  {…}
};
struct ball_order {…};
 
typedef typename std::set<ball_t*,ball_order>::const_iterator ball_it;
typedef typename std::set<ball_t*,ball_order>::const_reverse_iterator ball_rev_it;


class pocket_t : public std::set<ball_t*,ball_order> {
 
private:

  void clean (void) {
    for (ball_t *b : *this) delete b;
    clear();
  };
  void clean (void) {…}
 
public:
 
  // SERIALIZATION
  size_t bytesize (void) const {
    return sizeof(size_t) + size()*(ball_t::bytesize);
  };
  size_t bytesize (void) const  {…}

  friend raw_t* operator>> (const pocket_t &p, raw_t *o) {
    size_t psize = p.size();
    memcpy(o,&psize,sizeof(size_t)); o += sizeof(size_t);
    for (ball_t *i : p)
      o = (*i >> o);
    return o;
  };
  friend raw_t* operator>> (const pocket_t &p, raw_t *o) {…}

  friend raw_t* operator>> (raw_t *o, pocket_t &p) {
    p.clean();
    size_t psize;
    memcpy(&psize,o,sizeof(size_t)); o += sizeof(size_t);
    for (size_t i = 0; i < psize; i++) {
      ball_t *b = new ball_t();
      o = (o >> *b);
      p.insert(b);
    }
    return o;
  };
  friend raw_t* operator>> (raw_t *o, pocket_t &p) {…}
 
protected:
  void repair_holder (node_t* p) {
    for (ball_t *b : *this) {
      b->holder() = p;
    }
  };
  void repair_holder (node_t* p) {…}
 
public:
  void repair_owners (const std::unordered_map<name_t,node_t*>& node_name,
                      std::unordered_map<name_t,ball_t*> *ball_name) {
    std::unordered_map<name_t,node_t*>::const_iterator n;
    for (ball_t *b : *this) {
      if (b->is(green)) {
        n = node_name.find(b->uniq);
        if (n != node_name.end()) {
          node_t *p = n->second;
          b->owner() = p;
          ball_name->insert({b->uniq,b});
        } else {
          err("in '%s' (%s line %d): cannot find ball %zd", // #nocov
              __func__,__FILE__,__LINE__,b->uniq);          // #nocov
        }
      }
    }
  };
  void repair_owners (const std::unordered_map<name_t,node_t*>& node_name, {…}
 
public:

  ~pocket_t (void) {
    clean();
  };
  ~pocket_t (void) {…}
 
public:

  bool holds (ball_t *b) const {
    ball_it i = find(b);
    return (i != end());
  };
  bool holds (ball_t *b) const  {…}

  bool holds (color_t c) const {
    bool result = false;
    for (ball_it i = begin(); !result && i != end(); i++) {
      result = ((*i)->color == c);
    }
    return result;
  };
  bool holds (color_t c) const  {…}

  ball_t* last_ball (void) const {
    return *crbegin();
  };
  ball_t* last_ball (void) const  {…}

  ball_t* ball (const color_t c) const {
    for (ball_t *b : *this) {
      if (b->color == c) return b;
    }
    err("in '%s' (%s line %d): no ball of color %s", // # nocov
        __func__,__FILE__,__LINE__,colores[c]);      // # nocov
    return 0;
  };
  ball_t* ball (const color_t c) const  {…}

  ball_t* other (const ball_t *b) const {
    for (ball_t *a : *this) {
      if (a != b) return a;
    }
    err("error in '%s' (%s line %d): there is no other.", // # nocov
        __func__,__FILE__,__LINE__);                      // # nocov
    return 0;
  };
  ball_t* other (const ball_t *b) const  {…}

  std::string describe (void) const {
    std::string s = "{";
    ball_it i = begin();
    s += (*i)->describe(); ++i;
    while (i != end()) {
      s += ", " + (*i)->describe(); ++i;
    }
    s += "}";
    return s;
  };
  std::string describe (void) const  {…}

  SEXP structure (void) const {
    SEXP o;
    PROTECT(o = NEW_LIST(size()));
    int k = 0;
    for (ball_rev_it i = crbegin(); i != crend(); i++) {
      SET_ELEMENT(o,k++,(*i)->structure());
    }
    UNPROTECT(1);
    return o;
  };
  SEXP structure (void) const  {…}

  std::string yaml (std::string tab = "") const {
    std::string o = "";
    std::string t = tab + "  ";
    for (ball_t *b : *this) {
      o += tab + "- " + b->yaml(t);
    }
    return o;
  };
  std::string yaml (std::string tab = "") const  {…}
};
class pocket_t : public std::set<ball_t*,ball_order> {…};
 
#endif