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 *	first_ball (void) const
	retrieve the first ball
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
string_t	yaml (string_t tab="") const
	human/machine-readable info
SEXP	structure (void) const
	R list description.

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 30 of file pocket.h.

Constructor & Destructor Documentation

~pocket_t()

pocket_t::~pocket_t ( void )

inline

destructor

Definition at line 102 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 130 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;
  };

Here is the caller graph for this function:

bytesize()

size_t pocket_t::bytesize ( void ) const

inline

size of binary serialization

Definition at line 44 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 35 of file pocket.h.

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

Here is the caller graph for this function:

first_ball()

ball_t * pocket_t::first_ball ( void ) const

inline

retrieve the first ball

Definition at line 122 of file pocket.h.

                                  {
    return *cbegin();
  };

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 109 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 114 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 126 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 139 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 72 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 81 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

R list description.

Definition at line 40 of file structure.cc.

{
  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()

string_t pocket_t::yaml

(

string_t

tab = ""

)

const

human/machine-readable info

Definition at line 24 of file yaml.cc.

{
  string_t o = "";
  string_t 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 48 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 57 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 files:

• src/pocket.h
• src/structure.cc
• src/yaml.cc