g4tools  5.4.0
Public Member Functions | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
tools::rroot::buffer Class Reference
Inheritance diagram for tools::rroot::buffer:
Inheritance graph
[legend]
Collaboration diagram for tools::rroot::buffer:
Collaboration graph
[legend]

Public Member Functions

 buffer (std::ostream &a_out, bool a_byte_swap, uint32 a_size, char *a_buffer, uint32 a_klen, bool a_verbose)
 
virtual ~buffer ()
 
bool byte_swap () const
 
bool verbose () const
 
void set_offset (unsigned int a_off)
 
uint32 length () const
 
uint32 size () const
 
void set_map_objs (bool a_value)
 
bool map_objs () const
 
void remove_in_map (iro *a_obj)
 
bool read_object (ifac &a_fac, const ifac::args &a_args, iro *&a_obj, bool &a_created)
 
bool read_version (short &a_version)
 
bool read_version (short &a_version, uint32 &a_start_pos, uint32 &a_byte_count)
 
bool check_byte_count (uint32 a_start_pos, uint32 a_byte_count, const std::string &a_store_cls)
 
- Public Member Functions inherited from tools::rroot::rbuf
 rbuf (std::ostream &a_out, bool a_byte_swap, const char *a_eob, char *&a_pos)
 
virtual ~rbuf ()
 
 rbuf (const rbuf &a_from)
 
rbuf & operator= (const rbuf &a_from)
 
std::ostream & out () const
 
void skip (unsigned int a_num)
 
void set_eob (const char *a_eob)
 
char *& pos ()
 
const char * eob () const
 
void set_byte_swap (bool a_value)
 
bool read (unsigned char &a_x)
 
bool read (unsigned short &a_x)
 
bool read (unsigned int &a_x)
 
bool read (uint64 &a_x)
 
bool read (float &a_x)
 
bool read (double &a_x)
 
bool read (char &a_x)
 
bool read (short &a_x)
 
bool read (int &a_x)
 
bool read (int64 &a_x)
 
bool read (std::string &a_x)
 
bool read (bool &x)
 
bool read (std::vector< std::string > &a_a)
 
bool read_fast_array (bool *b, uint32 n)
 
bool read_fast_array (char *c, uint32 n)
 
bool read_fast_array (unsigned char *c, uint32 n)
 
template<class T >
bool read_fast_array (T *a_a, uint32 a_n)
 
template<class T >
bool read_array (uint32 a_sz, T *&a_a, uint32 &a_n)
 
template<class T >
bool read_array (std::vector< T > &a_v)
 
template<class T >
bool read_array2 (std::vector< std::vector< T > > &a_v)
 
bool check_eob (uint32 n)
 

Protected Member Functions

 buffer (const buffer &a_from)
 
buffer & operator= (const buffer &)
 
bool read_class_tag (std::string &a_class)
 
bool read_class (std::string &a_class, uint32 &a_bcnt, bool &a_is_ref)
 
bool read_string (char *a_string, uint32 a_max)
 
- Protected Member Functions inherited from tools::rroot::rbuf
template<class T >
bool _check_eob (T &a_x)
 

Static Protected Member Functions

static uint32 kNullTag ()
 
static uint32 kByteCountMask ()
 
static uint32 kNewClassTag ()
 
static uint32 kClassMask ()
 
static uint32 kMapOffset ()
 
static short kByteCountVMask ()
 

Protected Attributes

bool m_byte_swap
 
bool m_verbose
 
uint32 m_size
 
char * m_buffer
 
char * m_pos
 
uint32 m_klen
 
bool m_map_objs
 
obj_map m_objs
 
- Protected Attributes inherited from tools::rroot::rbuf
std::ostream & m_out
 
bool m_byte_swap
 
const char * m_eob
 
char *& m_pos
 
r_2_func m_r_2_func
 
r_4_func m_r_4_func
 
r_8_func m_r_8_func
 

Detailed Description

Definition at line 43 of file buffer.

Constructor & Destructor Documentation

◆ buffer() [1/2]

tools::rroot::buffer::buffer ( std::ostream &  a_out,
bool  a_byte_swap,
uint32  a_size,
char *  a_buffer,
uint32  a_klen,
bool  a_verbose 
)
inline

Definition at line 80 of file buffer.

81  :parent(a_out,a_byte_swap,a_buffer+a_size,m_pos)
82  ,m_byte_swap(a_byte_swap)
83  ,m_verbose(a_verbose)
84  //,m_verbose(true)
85  ,m_size(a_size) //expect a not zero size.
86  ,m_buffer(a_buffer) //don't get ownership.
87  ,m_pos(a_buffer)
88  ,m_klen(a_klen) //to compute refs (used in read_class, read_object)
89 //,m_map_objs(false)
90  ,m_map_objs(true)
91  {
92 #ifdef TOOLS_MEM
93  mem::increment(s_class().c_str());
94 #endif
95  }

◆ ~buffer()

virtual tools::rroot::buffer::~buffer ( )
inlinevirtual

Definition at line 96 of file buffer.

96  {
97  m_objs.clear();
98 #ifdef TOOLS_MEM
99  mem::decrement(s_class().c_str());
100 #endif
101  }

◆ buffer() [2/2]

tools::rroot::buffer::buffer ( const buffer &  a_from)
inlineprotected

Definition at line 103 of file buffer.

104  :parent(a_from.m_out,a_from.m_byte_swap,0,m_pos)
105  ,m_byte_swap(a_from.m_byte_swap)
106  ,m_map_objs(a_from.m_map_objs)
107  {
108 #ifdef TOOLS_MEM
109  mem::increment(s_class().c_str());
110 #endif
111  }

Member Function Documentation

◆ byte_swap()

bool tools::rroot::buffer::byte_swap ( ) const
inline

Definition at line 114 of file buffer.

114 {return m_byte_swap;}

◆ check_byte_count()

bool tools::rroot::buffer::check_byte_count ( uint32  a_start_pos,
uint32  a_byte_count,
const std::string &  a_store_cls 
)
inline

Definition at line 568 of file buffer.

568  {
569  if(!a_byte_count) return true;
570 
571  size_t len = a_start_pos + a_byte_count + sizeof(unsigned int);
572 
573  size_t diff = size_t(m_pos-m_buffer);
574 
575  if(diff==len) return true;
576 
577  if(diff<len) {
578  m_out << "tools::rroot::buffer::check_byte_count :"
579  << " object of class " << sout(a_store_cls)
580  << " read too few bytes ("
581  << long_out(long(len-diff)) << " missing)."
582  << std::endl;
583  }
584  if(diff>len) {
585  m_out << "tools::rroot::buffer::check_byte_count :"
586  << " object of class " << sout(a_store_cls)
587  << " read too many bytes ("
588  << long_out(long(diff-len)) << " in excess)." << std::endl;
589  }
590 
591  m_out << "tools::rroot::buffer::check_byte_count :"
592  << " " << sout(a_store_cls)
593  << " streamer not in sync with data on file, fix streamer."
594  << std::endl;
595 
596  m_pos = m_buffer+len;
597 
598  return false;
599  }

◆ kByteCountMask()

static uint32 tools::rroot::buffer::kByteCountMask ( )
inlinestaticprotected

Definition at line 128 of file buffer.

128 {return 0x40000000;}

◆ kByteCountVMask()

static short tools::rroot::buffer::kByteCountVMask ( )
inlinestaticprotected

Definition at line 133 of file buffer.

133 {return 0x4000;}

◆ kClassMask()

static uint32 tools::rroot::buffer::kClassMask ( )
inlinestaticprotected

Definition at line 131 of file buffer.

131 {return 0x80000000; }

◆ kMapOffset()

static uint32 tools::rroot::buffer::kMapOffset ( )
inlinestaticprotected

Definition at line 132 of file buffer.

132 {return 2;}

◆ kNewClassTag()

static uint32 tools::rroot::buffer::kNewClassTag ( )
inlinestaticprotected

Definition at line 130 of file buffer.

130 {return 0xFFFFFFFF;}

◆ kNullTag()

static uint32 tools::rroot::buffer::kNullTag ( )
inlinestaticprotected

Definition at line 127 of file buffer.

127 {return 0;}

◆ length()

uint32 tools::rroot::buffer::length ( ) const
inline

Definition at line 120 of file buffer.

120 {return uint32(m_pos-m_buffer);}

◆ map_objs()

bool tools::rroot::buffer::map_objs ( ) const
inline

Definition at line 124 of file buffer.

124 {return m_map_objs;}

◆ operator=()

buffer& tools::rroot::buffer::operator= ( const buffer &  )
inlineprotected

Definition at line 112 of file buffer.

112 {return *this;}

◆ read_class()

bool tools::rroot::buffer::read_class ( std::string &  a_class,
uint32 &  a_bcnt,
bool &  a_is_ref 
)
inlineprotected

Definition at line 187 of file buffer.

187  {
188  //m_verbose = true;
189  a_class.clear();
190  a_bcnt = 0;
191  a_is_ref = false;
192 
193  //uint32 fVersion = 0; //Buffer format version
194 
195  // read byte count and/or tag (older files don't have byte count)
196  uint32 first_int = 0;
197  if(!parent::read(first_int)) return false;
198 
199  if(m_verbose) {
200  std::ios::fmtflags old_flags = m_out.flags();
201  m_out << "tools::rroot::read_class :"
202  << " first_int " << std::hex << first_int
203  << std::endl;
204  m_out.flags(old_flags);
205  }
206 
207  if(first_int==kNullTag()) { //GB
208  if(m_verbose) {
209  m_out << "tools::rroot::read_class :"
210  << " first_int is kNullTag."
211  << std::endl;
212  }
213  a_bcnt = 0;
214  return true;
215 
216  //} else if(first_int==kNewClassTag()) { // class desc follows.
217  } else if(first_int & kByteCountMask()) {
218  // at write :
219  // skip int to store bcnt.
220  // + write class
221  // if(!write((clIdx | Rio_kClassMask))) return false;
222  // or
223  // if(!write(Rio_kNewClassTag)) return false;
224  // + write object
225  // + set byte cnt (cnt|kByteCountMask()) at skipped int.
226 
227  if(m_verbose) {
228  m_out << "tools::rroot::read_class :"
229  << " first_int & kByteCountMask."
230  << std::endl;
231  }
232 
233  uint32 bef_tag = uint32(m_pos-m_buffer);
234  //fVersion = 1;
235 
236  std::string scls;
237  if(!read_class_tag(scls)) return false;
238  if(scls.empty()) {
239  m_out << "tools::rroot::buffer::read_class :"
240  << " read_class_tag did not find a class name."
241  << std::endl;
242  return false;
243  }
244 
245  a_class = scls;
246  a_bcnt = (first_int & ~kByteCountMask());
247 
248  if(m_verbose) {
249  m_out << "tools::rroot::read_class :"
250  << " kNewClassTag : read class name " << sout(a_class)
251  << " a_bcnt " << a_bcnt
252  << " bef_tag " << bef_tag
253  << "." << std::endl;
254  }
255 
256  return true;
257 
258  } else {
259  if(m_verbose) {
260  std::ios::fmtflags old_flags = m_out.flags();
261  m_out << "tools::rroot::read_class :"
262  << " first_int " << std::hex << first_int
263  << ". first_int is position toward object."
264  << std::endl;
265  m_out.flags(old_flags);
266  }
267  a_bcnt = first_int; //pos toward object.
268  a_is_ref = true;
269  a_class.clear();
270  return true;
271  }
272 
273  return false;
274  }

◆ read_class_tag()

bool tools::rroot::buffer::read_class_tag ( std::string &  a_class)
inlineprotected

Definition at line 135 of file buffer.

135  {
136  a_class.clear();
137 
138  uint32 tag;
139  if(!parent::read(tag)) return false;
140 
141  if(tag==kNewClassTag()) {
142  char s[80];
143  if(!read_string(s, 80)) {
144  m_out << "tools::rroot::read_class_tag :"
145  << " read string." << std::endl;
146  return false;
147  }
148  //m_out << "tools::rroot::read_class_tag :"
149  // << " tag kNewClassTag"
150  // << " class " << s
151  // << std::endl;
152  a_class = s;
153  return true;
154 
155  } else if(tag & kClassMask()) {
156  //m_out << "tools::rroot::read_class_tag :"
157  // << " tag & kClassMask"
158  // << " ref " << (uint32)(tag & ~kClassMask)
159  // << " recurse..."
160  // << std::endl;
161 
162  unsigned int cl_offset = (tag & ~kClassMask());
163  cl_offset -= kMapOffset();
164  cl_offset -= m_klen;
165  char* old_pos = m_pos;
166  m_pos = m_buffer + cl_offset;
167  //std::string scls;
168  //uint32 ref;
169  if(!read_class_tag(a_class)) return false;
170  m_pos = old_pos;
171 
172  return true;
173 
174  } else {
175 
176  std::ios::fmtflags old_flags = m_out.flags();
177  m_out << "tools::rroot::read_class_tag :"
178  << " tag unknown case ! "
179  << tag << " hex " << std::hex << tag
180  << std::endl;
181  m_out.flags(old_flags);
182 
183  return false;
184  }
185  }

◆ read_object()

bool tools::rroot::buffer::read_object ( ifac &  a_fac,
const ifac::args &  a_args,
iro *&  a_obj,
bool &  a_created 
)
inline

Definition at line 283 of file buffer.

283  {
284  a_obj = 0;
285  a_created = false;
286 
287  //m_out << "debug : tools::rroot::buffer::read_object : begin :" << std::endl;
288 
289  // before reading object save start position
290  uint32 startpos = (uint32)(m_pos-m_buffer);
291 
292  uint32 bcnt;
293  std::string sclass;
294  bool is_ref;
295  if(!read_class(sclass,bcnt,is_ref)) {
296  m_out << "tools::rroot::buffer::read_object :"
297  << " can't read class." << std::endl;
298  return false;
299  }
300  //::printf("debug : %d\n",length()-startpos);
301 
302  if(m_verbose) {
303  m_out << "tools::rroot::buffer::read_object :"
304  << " class " << sout(sclass) << ", is_ref " << is_ref
305  << ", bcnt " << bcnt
306  << std::endl;
307  }
308 
309  if(is_ref) { //bcnt is the position toward an object or an object ref.
310  //m_out << "debug : tools::rroot::buffer::read_object : is_ref : bcnt " << bcnt << std::endl;
311 
312  unsigned int obj_offset = bcnt;
313  obj_offset -= kMapOffset();
314  obj_offset -= m_klen;
315 
316  if(!m_map_objs) {
317  m_out << "tools::rroot::buffer::read_object : warning :"
318  << " class " << sout(sclass) << ", is_ref but map objs is not enabled on this buffer."
319  << std::endl;
320  }
321 
322  if(m_map_objs) {
323 #ifdef TOOLS_RROOT_OBJ_MAP_HASH_TABLE
324  if(m_objs.find(obj_offset,a_obj)) {
325  //m_out << "debug : tools::rroot::buffer::read_object : found object in map." << bcnt << std::endl;
326  return true;
327  }
328 #else
329  obj_map::const_iterator it = m_objs.find(obj_offset);
330  if(it!=m_objs.end()) {
331  a_obj = (*it).second;
332  //::printf("debug : find : %d %lu\n",obj_offset,a_obj);
333  //stay at current m_pos ?
334  return true;
335  }
336 #endif
337  }
338 
339  {char* old_pos = m_pos;
340 
341  m_pos = m_buffer + obj_offset;
342 
343  uint32 first_int;
344  if(!parent::read(first_int)) {
345  m_out << "tools::rroot::buffer::read_object : parent::read(first_int) failed." << std::endl;
346  return false;
347  }
348  if(first_int & kByteCountMask()) {
349  std::string scls;
350  if(!read_class_tag(scls)) {
351  m_out << "tools::rroot::buffer::read_object : read_class_tag() failed." << std::endl;
352  return false;
353  }
354  if(scls.empty()) {
355  m_out << "tools::rroot::buffer::read_object :"
356  << " read_class_tag did not find a class name."
357  << std::endl;
358  return false;
359  }
360 
361  //m_out << "tools::rroot::buffer::read_object :"
362  // << " is_ref : class " << sout(scls)
363  // << std::endl;
364 
365  iro* obj = a_fac.create(scls,a_args);
366  if(!obj) {
367  m_out << "tools::rroot::buffer::read_object : is_ref : creation of object"
368  << " of class " << sout(sclass) << " failed." << std::endl;
369  return false;
370  }
371 
372  if(m_map_objs) {
373  //must be done before stream()
374 #ifdef TOOLS_RROOT_OBJ_MAP_HASH_TABLE
375  if(!m_objs.insert(obj_offset,obj)) {
376  m_out << "tools::rroot::buffer::read_object :"
377  << " map insert failed."
378  << std::endl;
379  }
380 #else
381  m_objs[obj_offset] = obj;
382 #endif
383  }
384 
385  if(!obj->stream(*this)) {
386  m_out << "tools::rroot::buffer::read_object :"
387  << " is_ref : streamed failed for class " << sout(scls)
388  << std::endl;
389  //restore a good buffer position :
390  //m_pos = m_buffer+startpos+sizeof(unsigned int);
391  delete obj;
392  return false;
393  }
394 
395  //m_out << "tools::rroot::buffer::read_object :"
396  // << " is_ref : streamed ok for class " << sout(scls)
397  // << std::endl;
398 
399  a_obj = obj;
400  a_created = true;
401 
402  } else {
403  m_out << "tools::rroot::buffer::read_object :"
404  << " is_ref : zzz"
405  << std::endl;
406  }
407 
408  m_pos = old_pos;}
409 
410  // in principle at this point m_pos should be
411  // m_buffer+startpos+sizeof(unsigned int)
412  // but enforce it anyway :
413  m_pos = m_buffer+startpos+sizeof(unsigned int);
414  //check_byte_count(startpos,0,sclass) would always be ok.
415 
416  //a_obj = ???
417 
418  } else {
419  if(sclass.empty()) {
420  //m_out << "debug : tools::rroot::buffer::read_object : found empty class name." << std::endl;
421 
422  m_pos = m_buffer+startpos+bcnt+sizeof(unsigned int);
423 
424  } else {
425  //m_out << "debug : tools::rroot::buffer::read_object : not a ref, create object." << std::endl;
426 
427  // Being not a ref, it must NOT be in the map.
428  // We gain a lot by not doing the below find.
429 /*
430  if(m_map_objs) {
431 #ifdef TOOLS_RROOT_OBJ_MAP_HASH_TABLE
432  if(m_objs.find(startpos,a_obj)) return true;
433 #else
434  obj_map::const_iterator it = m_objs.find(startpos);
435  if(it!=m_objs.end()) {
436  a_obj = (*it).second;
437  ::printf("debug : find xxx : %d %lu\n",startpos,a_obj);
438  //stay at current m_pos ?
439  return true;
440  }
441 #endif
442  }
443 */
444 
445  iro* obj = a_fac.create(sclass,a_args);
446  if(!obj) {
447  m_out << "tools::rroot::buffer::read_object : creation of object"
448  << " of class " << sout(sclass) << " failed." << std::endl;
449  return false;
450  }
451  //m_out << "debug : tools::rroot::buffer::read_object : object created." << std::endl;
452 
453  if(m_map_objs) {
454  //must be done before stream()
455 #ifdef TOOLS_RROOT_OBJ_MAP_HASH_TABLE
456  if(!m_objs.insert(startpos,obj)) {
457  m_out << "tools::rroot::buffer::read_object :"
458  << " map insert failed."
459  << std::endl;
460  }
461 #else
462  m_objs[startpos] = obj;
463 #endif
464  }
465 
466  //::printf("debug : map : %d %lu\n",startpos,obj);
467 
468  //NOTE : if class ref, "up there"-startpos = 8.
469  if(!obj->stream(*this)) {
470  m_out << "tools::rroot::buffer::read_object : object.stream() failed"
471  << " for object of class " << sout(sclass) << "." << std::endl;
472  //restore a good buffer position :
473  //m_pos = m_buffer+startpos+bcnt+sizeof(unsigned int);
474  delete obj;
475  return false;
476  }
477 
478  //NOTE : if obj stream ok, the below line is not needed.
479  //m_pos = m_buffer+startpos+bcnt+sizeof(unsigned int);
480 
481  if(!check_byte_count(startpos,bcnt,sclass)) {
482  m_out << "tools::rroot::buffer::read_object :"
483  << " check_byte_count failed "
484  << "for object of class "
485  << sout(sclass) << "." << std::endl;
486  delete obj;
487  return false;
488  }
489 
490  a_obj = obj;
491  a_created = true;
492  }
493 
494  }
495 
496  if(m_verbose) {
497  m_out << "tools::rroot::buffer::read_object : end." << std::endl;
498  }
499 
500  return true;
501  }

◆ read_string()

bool tools::rroot::buffer::read_string ( char *  a_string,
uint32  a_max 
)
inlineprotected

Definition at line 601 of file buffer.

601  {
602  // Read string from I/O buffer. String is read till 0 character is
603  // found or till max-1 characters are read (i.e. string s has max
604  // bytes allocated).
605  int nr = 0;
606  while (nr < int(a_max-1)) {
607  char ch;
608  if(!parent::read(ch)) return false;
609  // stop when 0 read
610  if(ch == 0) break;
611  a_string[nr++] = ch;
612  }
613  a_string[nr] = 0;
614  return true;
615  }

◆ read_version() [1/2]

bool tools::rroot::buffer::read_version ( short &  a_version)
inline

Definition at line 503 of file buffer.

503  {
504  // Read class version from I/O buffer.
505  // Is read a short or three shorts.
506  a_version = 0;
507  short version = 0;
508  // not interested in byte count
509  if(!parent::read(version)) return false;
510 
511  // if this is a byte count, then skip next short and read version
512  if(version & kByteCountVMask()) {
513  if(!parent::read(version)) return false;
514  if(!parent::read(version)) return false;
515  }
516 
517  a_version = version;
518  return true;
519  }

◆ read_version() [2/2]

bool tools::rroot::buffer::read_version ( short &  a_version,
uint32 &  a_start_pos,
uint32 &  a_byte_count 
)
inline

Definition at line 521 of file buffer.

521  {
522  // Read class version from I/O buffer.
523  // Is read one or three shorts.
524  a_version = 0;
525  a_start_pos = 0;
526  a_byte_count = 0;
527 
528  short version = 0;
529 
530  // before reading object save start position
531  uint32 startpos = (uint32)(m_pos-m_buffer);
532 
533  // read byte count (older files don't have byte count)
534  // byte count is packed in two individual shorts, this to be
535  // backward compatible with old files that have at this location
536  // only a single short (i.e. the version)
537  union {
538  unsigned int cnt;
539  short vers[2];
540  } v;
541 
542  if(m_byte_swap) {
543  if(!parent::read(v.vers[1])) return false;
544  if(!parent::read(v.vers[0])) return false;
545  } else {
546  if(!parent::read(v.vers[0])) return false;
547  if(!parent::read(v.vers[1])) return false;
548  }
549 
550  // no bytecount, backup and read version
551  uint32 bcnt = 0;
552  if(v.cnt & kByteCountMask()) {
553  bcnt = (v.cnt & ~kByteCountMask());
554  } else {
555  m_pos -= sizeof(unsigned int);
556  }
557  if(!parent::read(version)) return false;
558  //printf("Reading version=%d at pos=%d, bytecount=%d\n",
559  //version,*startpos,*bcnt);
560 
561  a_version = version;
562  a_start_pos = startpos;
563  a_byte_count = bcnt;
564 
565  return true;
566  }

◆ remove_in_map()

void tools::rroot::buffer::remove_in_map ( iro *  a_obj)
inline

Definition at line 276 of file buffer.

276  {
277 #ifdef TOOLS_RROOT_OBJ_MAP_HASH_TABLE
278  m_out << "tools::rroot::remove_in_map : dummy." << std::endl;
279 #else
280  find_and_remove_value(m_objs,a_obj);
281 #endif
282  }

◆ set_map_objs()

void tools::rroot::buffer::set_map_objs ( bool  a_value)
inline

Definition at line 123 of file buffer.

123 {m_map_objs = a_value;}

◆ set_offset()

void tools::rroot::buffer::set_offset ( unsigned int  a_off)
inline

Definition at line 117 of file buffer.

117 {m_pos = m_buffer+a_off;}

◆ size()

uint32 tools::rroot::buffer::size ( ) const
inline

Definition at line 121 of file buffer.

121 {return m_size;}

◆ verbose()

bool tools::rroot::buffer::verbose ( ) const
inline

Definition at line 115 of file buffer.

115 {return m_verbose;}

Member Data Documentation

◆ m_buffer

char* tools::rroot::buffer::m_buffer
protected

Definition at line 624 of file buffer.

◆ m_byte_swap

bool tools::rroot::buffer::m_byte_swap
protected

Definition at line 621 of file buffer.

◆ m_klen

uint32 tools::rroot::buffer::m_klen
protected

Definition at line 626 of file buffer.

◆ m_map_objs

bool tools::rroot::buffer::m_map_objs
protected

Definition at line 627 of file buffer.

◆ m_objs

obj_map tools::rroot::buffer::m_objs
protected

Definition at line 628 of file buffer.

◆ m_pos

char* tools::rroot::buffer::m_pos
protected

Definition at line 625 of file buffer.

◆ m_size

uint32 tools::rroot::buffer::m_size
protected

Definition at line 623 of file buffer.

◆ m_verbose

bool tools::rroot::buffer::m_verbose
protected

Definition at line 622 of file buffer.

The documentation for this class was generated from the following file:
tools::rroot::buffer::m_klen
uint32 m_klen
Definition: buffer:626
tools::rroot::buffer::check_byte_count
bool check_byte_count(uint32 a_start_pos, uint32 a_byte_count, const std::string &a_store_cls)
Definition: buffer:568
tools::rroot::buffer::kMapOffset
static uint32 kMapOffset()
Definition: buffer:132
tools::rroot::buffer::m_size
uint32 m_size
Definition: buffer:623
tools::rroot::buffer::m_byte_swap
bool m_byte_swap
Definition: buffer:621
tools::rroot::buffer::kByteCountMask
static uint32 kByteCountMask()
Definition: buffer:128
tools::rroot::buffer::kNullTag
static uint32 kNullTag()
Definition: buffer:127
tools::rroot::buffer::m_objs
obj_map m_objs
Definition: buffer:628
tools::rroot::buffer::read_class
bool read_class(std::string &a_class, uint32 &a_bcnt, bool &a_is_ref)
Definition: buffer:187
tools::version
unsigned int version()
Definition: version:14
tools::rroot::buffer::m_verbose
bool m_verbose
Definition: buffer:622
tools::rroot::buffer::read_string
bool read_string(char *a_string, uint32 a_max)
Definition: buffer:601
tools::rroot::buffer::read_class_tag
bool read_class_tag(std::string &a_class)
Definition: buffer:135
tools::rroot::buffer::m_pos
char * m_pos
Definition: buffer:625
tools::rroot::buffer::kByteCountVMask
static short kByteCountVMask()
Definition: buffer:133
tools::rroot::buffer::kNewClassTag
static uint32 kNewClassTag()
Definition: buffer:130
tools::diff
void diff(std::ostream &a_out, const array< T > &aA, const array< T > &aB, T a_epsilon)
Definition: array:529
tools::rroot::buffer::kClassMask
static uint32 kClassMask()
Definition: buffer:131
tools::rroot::rbuf::read
bool read(unsigned char &a_x)
Definition: rbuf:146
tools::find_and_remove_value
void find_and_remove_value(std::map< K, V * > &a_m, V *a_value)
Definition: mapmanip:25
tools::rroot::buffer::m_buffer
char * m_buffer
Definition: buffer:624
tools::rroot::buffer::m_map_objs
bool m_map_objs
Definition: buffer:627
tools::uint32
unsigned int uint32
Definition: typedefs:71
tools::rroot::rbuf::m_out
std::ostream & m_out
Definition: rbuf:400
Generated by doxygen 1.8.20