pocket_t Class Reference

A pocket is a set of balls. More...

#include <pocket.h>

Inheritance diagram for pocket_t:

Collaboration diagram for pocket_t:

Public Member Functions
size_t	bytesize (void) const
	size of binary serialization
void	repair_owners (const std::unordered_map< name_t, node_t * > &node_name, std::unordered_map< name_t, ball_t * > *ball_name)
	~pocket_t (void)
	destructor
bool	holds (ball_t *b) const
	does this node hold the given ball?
bool	holds (color_t c) const
	does this node hold a ball of this color?
ball_t *	last_ball (void) const
	retrieve the last ball
ball_t *	ball (const color_t c) const
	retrieve the first ball of the specified color.
ball_t *	other (const ball_t *b) const
	return a pointer to another ball
std::string	describe (void) const
	human-readable info
SEXP	structure (void) const
	R list description.
std::string	yaml (std::string tab="") const
	human/machine-readable info

Protected Member Functions
void	repair_holder (node_t *p)

Private Member Functions
void	clean (void)
	delete balls and clear pocket

Friends
raw_t *	operator>> (const pocket_t &p, raw_t *o)
	binary serialization
raw_t *	operator>> (raw_t *o, pocket_t &p)

Detailed Description

A pocket is a set of balls.

An order relation among balls ensures the uniqueness of the internal representation.

Definition at line 32 of file pocket.h.

Constructor & Destructor Documentation

~pocket_t()

pocket_t::~pocket_t ( void )

inline

destructor

Definition at line 104 of file pocket.h.

                   {
    clean();
  };

Here is the call graph for this function:

Member Function Documentation

ball()

ball_t * pocket_t::ball ( const color_t c ) const

inline

retrieve the first ball of the specified color.

Definition at line 128 of file pocket.h.

                                       {
    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;
  };

bytesize()

size_t pocket_t::bytesize ( void ) const

inline

size of binary serialization

Definition at line 46 of file pocket.h.

                               {
    return sizeof(size_t) + size()*(ball_t::bytesize);
  };

Here is the caller graph for this function:

clean()

void pocket_t::clean ( void )

inlineprivate

delete balls and clear pocket

Definition at line 37 of file pocket.h.

                    {
    for (ball_t *b : *this) delete b;
    clear();
  };

Here is the caller graph for this function:

describe()

std::string pocket_t::describe ( void ) const

inline

human-readable info

Definition at line 146 of file pocket.h.

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

Here is the caller graph for this function:

holds() [1/2]

bool pocket_t::holds ( ball_t * b ) const

inline

does this node hold the given ball?

Definition at line 111 of file pocket.h.

                               {
    ball_it i = find(b);
    return (i != end());
  };

Here is the caller graph for this function:

holds() [2/2]

bool pocket_t::holds ( color_t c ) const

inline

does this node hold a ball of this color?

Definition at line 116 of file pocket.h.

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

last_ball()

ball_t * pocket_t::last_ball ( void ) const

inline

retrieve the last ball

Definition at line 124 of file pocket.h.

                                 {
    return *crbegin();
  };

Here is the caller graph for this function:

other()

ball_t * pocket_t::other ( const ball_t * b ) const

inline

return a pointer to another ball

Definition at line 137 of file pocket.h.

                                        {
    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;
  };

repair_holder()

void pocket_t::repair_holder ( node_t * p )

inlineprotected

Needed in deserialization. Inform all balls as to their holder.

Definition at line 74 of file pocket.h.

                                 {
    for (ball_t *b : *this) {
      b->holder() = p;
    }
  };

Here is the call graph for this function:

Here is the caller graph for this function:

repair_owners()

void pocket_t::repair_owners ( const std::unordered_map< name_t, node_t * > & node_name, std::unordered_map< name_t, ball_t * > * ball_name )

inline

Needed in deserialization. This function repairs the links green balls and their names.

Definition at line 83 of file pocket.h.

                                                                   {
    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
        }
      }
    }
  };

Here is the call graph for this function:

structure()

SEXP pocket_t::structure ( void ) const

inline

R list description.

Definition at line 157 of file pocket.h.

                              {
    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;
  };

Here is the caller graph for this function:

yaml()

std::string pocket_t::yaml ( std::string tab = "" ) const

inline

human/machine-readable info

Definition at line 168 of file pocket.h.

                                            {
    std::string o = "";
    std::string t = tab + "  ";
    for (ball_t *b : *this) {
      o += tab + "- " + b->yaml(t);
    }
    return o;
  };

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

operator>> [1/2]

raw_t * operator>> ( const pocket_t & p, raw_t * o )

friend

binary serialization

Definition at line 50 of file pocket.h.

                                                         {
    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;
  };

operator>> [2/2]

raw_t * operator>> ( raw_t * o, pocket_t & p )

friend

binary deserialization. this leaves the balls without knowledge of their holder.

Definition at line 59 of file pocket.h.

                                                   {
    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;
  };

---

The documentation for this class was generated from the following file:

• src/pocket.h