tools::wroot::buffer Class Reference

Inheritance diagram for tools::wroot::buffer:

Collaboration diagram for tools::wroot::buffer:

Public Member Functions
	buffer (std::ostream &a_out, bool a_byte_swap, uint32 a_size)
virtual	~buffer ()
bool	byte_swap () const
std::ostream &	out () const
char *	buf ()
const char *	buf () const
uint32	length () const
uint32	size () const
char *&	pos ()
char *	max_pos () const
template<class T >
bool	write (T x)
bool	write (bool x)
bool	write (const std::string &x)
bool	write_fast_array (const char *a_a, uint32 a_n)
bool	write_cstring (const char *a_s)
template<class T >
bool	write_fast_array (const T *a_a, uint32 a_n)
template<class T >
bool	write_fast_array (const std::vector< T > &a_v)
template<class T >
bool	write_array (const T *a_a, uint32 a_n)
template<class T >
bool	write_array (const std::vector< T > a_v)
template<class T >
bool	write_array2 (const std::vector< std::vector< T > > a_v)
bool	write_version (short a_version)
bool	write_version (short a_version, uint32 &a_pos)
bool	set_byte_count (uint32 a_pos)
bool	write_object (const ibo &a_obj)
bool	expand2 (uint32 a_new_size)
bool	expand (uint32 a_new_size)
size_t	to_displace () const
bool	displace_mapped (unsigned int a_num)
void	reset_objs_map ()

Protected Member Functions
	buffer (const buffer &a_from)
buffer &	operator= (const buffer &)
bool	write_class (const std::string &a_cls)
bool	set_byte_count_obj (uint32 a_pos)

Static Protected Member Functions
static short	kMaxVersion ()
static uint32	kMaxMapCount ()
static short	kByteCountVMask ()
static uint32	kNewClassTag ()
static int	kMapOffset ()
static unsigned int	kClassMask ()
static uint32	kByteCountMask ()

Protected Attributes
std::ostream &	m_out
bool	m_byte_swap
uint32	m_size
char *	m_buffer
char *	m_max
char *	m_pos
wbuf	m_wb
std::map< ibo *, uint32 >	m_objs
std::vector< std::pair< uint32, uint32 > >	m_obj_mapped
std::map< std::string, uint32 >	m_clss
std::vector< std::pair< uint32, uint32 > >	m_cls_mapped

Detailed Description

Definition at line 28 of file buffer.

Constructor & Destructor Documentation

buffer() [1/2]

tools::wroot::buffer::buffer ( std::ostream &  a_out, bool  a_byte_swap, uint32  a_size  )

inline

Definition at line 34 of file buffer.

  :m_out(a_out)
  ,m_byte_swap(a_byte_swap)
  ,m_size(0)
  ,m_buffer(0)
  ,m_max(0)
  ,m_pos(0)
  ,m_wb(a_out,a_byte_swap,0,m_pos) //it holds a ref on m_pos.
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
    m_size = a_size;
    m_buffer = new char[m_size];
    //if(!m_buffer) {}
    m_max = m_buffer+m_size;
    m_pos = m_buffer;
    m_wb.set_eob(m_max);
  }

~buffer()

virtual tools::wroot::buffer::~buffer ( )

inlinevirtual

Definition at line 54 of file buffer.

                   {
    m_objs.clear();
    m_obj_mapped.clear();
 
    m_clss.clear();
    m_cls_mapped.clear();
 
    delete [] m_buffer;
#ifdef TOOLS_MEM
    mem::decrement(s_class().c_str());
#endif
  }

buffer() [2/2]

tools::wroot::buffer::buffer ( const buffer &  a_from )

inlineprotected

Definition at line 67 of file buffer.

  :m_out(a_from.m_out)
  ,m_byte_swap(a_from.m_byte_swap)
  ,m_size(0)
  ,m_buffer(0)
  ,m_max(0)
  ,m_pos(0)
  ,m_wb(a_from.m_out,a_from.m_byte_swap,0,m_pos)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }

Member Function Documentation

buf() [1/2]

char* tools::wroot::buffer::buf ( )

inline

Definition at line 87 of file buffer.

{return m_buffer;}

buf() [2/2]

const char* tools::wroot::buffer::buf ( ) const

inline

Definition at line 88 of file buffer.

{return m_buffer;}

byte_swap()

bool tools::wroot::buffer::byte_swap ( ) const

inline

Definition at line 82 of file buffer.

{return m_byte_swap;}

displace_mapped()

bool tools::wroot::buffer::displace_mapped ( unsigned int  a_num )

inline

Definition at line 297 of file buffer.

                                          {
    char* opos = m_pos;
 
    //m_out << "tools::wroot::buffer::displace_mapped :"
    //      << " cls num " << m_cls_mapped.size()
    //      << std::endl;
 
    typedef std::pair<uint32,uint32> offset_id;
 
   {tools_vforcit(offset_id,m_cls_mapped,it) {
      unsigned int offset = (*it).first;
      unsigned int id = (*it).second;
      //m_out << "displace " << offset << " " << id << std::endl;
      m_pos = m_buffer+offset;
      unsigned int clIdx = id+a_num;
      if(!write(uint32(clIdx|kClassMask()))) {m_pos = opos;return false;}
    }}
 
    //m_out << "tools::wroot::buffer::displace_mapped :"
    //      << " obj num " << m_obj_mapped.size()
    //      << std::endl;
 
   {tools_vforcit(offset_id,m_obj_mapped,it) {
      uint32 offset = (*it).first;
      uint32 id = (*it).second;
      //m_out << "displace at " << offset
      //      << " the obj pos " << id
      //      << " by " << a_num
      //      << std::endl;
      m_pos = m_buffer+offset;
      unsigned int objIdx = id+a_num;
      if(!write(objIdx)) {m_pos = opos;return false;}
    }}
 
    m_pos = opos;
    return true;
  }

expand()

bool tools::wroot::buffer::expand ( uint32  a_new_size )

inline

Definition at line 276 of file buffer.

                                 {
    diff_pointer_t len = m_pos-m_buffer;
    if(!realloc<char>(m_buffer,a_new_size,m_size)) {
      m_out << "tools::wroot::buffer::expand :"
            << " can't realloc " << a_new_size << " bytes."
            << std::endl;
      m_size = 0;
      m_max = 0;
      m_pos = 0;
      m_wb.set_eob(m_max);
      return false;
    }
    m_size = a_new_size;
    m_max = m_buffer + m_size;
    m_pos = m_buffer + len;
    m_wb.set_eob(m_max);
    return true;
  }

expand2()

bool tools::wroot::buffer::expand2 ( uint32  a_new_size )

inline

Definition at line 274 of file buffer.

{return expand(mx<uint32>(2*m_size,a_new_size));} //CERN-ROOT logic.

kByteCountMask()

static uint32 tools::wroot::buffer::kByteCountMask ( )

inlinestaticprotected

Definition at line 347 of file buffer.

{return 0x40000000;}

kByteCountVMask()

static short tools::wroot::buffer::kByteCountVMask ( )

inlinestaticprotected

Definition at line 342 of file buffer.

{return 0x4000;}

kClassMask()

static unsigned int tools::wroot::buffer::kClassMask ( )

inlinestaticprotected

Definition at line 346 of file buffer.

{return 0x80000000;}

kMapOffset()

static int tools::wroot::buffer::kMapOffset ( )

inlinestaticprotected

Definition at line 345 of file buffer.

{return 2;}

kMaxMapCount()

static uint32 tools::wroot::buffer::kMaxMapCount ( )

inlinestaticprotected

Definition at line 341 of file buffer.

{return 0x3FFFFFFE;}

kMaxVersion()

static short tools::wroot::buffer::kMaxVersion ( )

inlinestaticprotected

Definition at line 340 of file buffer.

{return 0x3FFF;}

kNewClassTag()

static uint32 tools::wroot::buffer::kNewClassTag ( )

inlinestaticprotected

Definition at line 343 of file buffer.

{return 0xFFFFFFFF;}

length()

uint32 tools::wroot::buffer::length ( ) const

inline

Definition at line 89 of file buffer.

{return uint32(m_pos-m_buffer);}

max_pos()

char* tools::wroot::buffer::max_pos ( ) const

inline

Definition at line 93 of file buffer.

{return m_max;} //used in basket.

operator=()

buffer& tools::wroot::buffer::operator= ( const buffer &  )

inlineprotected

Definition at line 80 of file buffer.

{return *this;}

out()

std::ostream& tools::wroot::buffer::out ( ) const

inline

Definition at line 83 of file buffer.

{return m_out;}

pos()

char*& tools::wroot::buffer::pos ( )

inline

Definition at line 92 of file buffer.

{return m_pos;}          //used in basket.

reset_objs_map()

void tools::wroot::buffer::reset_objs_map ( )

inline

Definition at line 335 of file buffer.

                        {
    m_objs.clear();
    //m_clss.clear();
  }

set_byte_count()

bool tools::wroot::buffer::set_byte_count ( uint32  a_pos )

inline

Definition at line 199 of file buffer.

                                   {
    uint32 cnt = (uint32)(m_pos-m_buffer) - a_pos - sizeof(unsigned int);
    if(cnt>=kMaxMapCount()) {
      m_out << "tools::wroot::buffer::set_byte_count :"
            << " bytecount too large (more than "
            << kMaxMapCount() << ")."
            << std::endl;
      return false;
    }
 
    union {
      uint32 cnt;
      short vers[2];
    } v;
    v.cnt = cnt;
 
    char* opos = m_pos;
    m_pos = (char*)(m_buffer+a_pos);
    if(m_byte_swap) {
      if(!m_wb.write(short(v.vers[1]|kByteCountVMask())))
        {m_pos = opos;return false;}
      if(!m_wb.write(v.vers[0])) {m_pos = opos;return false;}
    } else {
      if(!m_wb.write(short(v.vers[0]|kByteCountVMask())))
        {m_pos = opos;return false;}
      if(!m_wb.write(v.vers[1])) {m_pos = opos;return false;}
    }
    m_pos = opos;
 
    return true;
  }

set_byte_count_obj()

bool tools::wroot::buffer::set_byte_count_obj ( uint32  a_pos )

inlineprotected

Definition at line 373 of file buffer.

                                       {
    uint32 cnt = (uint32)(m_pos-m_buffer) - a_pos - sizeof(unsigned int);
    if(cnt>=kMaxMapCount()) {
      m_out << "tools::wroot::buffer::set_byte_count_obj :"
            << " bytecount too large (more than "
            << kMaxMapCount() << ")."
            << std::endl;
      return false;
    }
    char* opos = m_pos;
    m_pos = (char*)(m_buffer+a_pos);
    if(!m_wb.write(uint32(cnt|kByteCountMask()))) {m_pos = opos;return false;}
    m_pos = opos;
    return true;
  }

size()

uint32 tools::wroot::buffer::size ( ) const

inline

Definition at line 90 of file buffer.

{return m_size;}

to_displace()

size_t tools::wroot::buffer::to_displace ( ) const

inline

Definition at line 295 of file buffer.

{return m_cls_mapped.size()+m_obj_mapped.size();}

write() [1/3]

bool tools::wroot::buffer::write ( bool  x )

inline

Definition at line 104 of file buffer.

{return write<unsigned char>(x?1:0);}

write() [2/3]

bool tools::wroot::buffer::write ( const std::string &  x )

inline

Definition at line 106 of file buffer.

                                 {
    uint32 sz = (uint32)(x.size() + sizeof(int) + 1);
    if((m_pos+sz)>m_max) {
      if(!expand2(m_size+sz)) return false;
    }
    return m_wb.write(x);
  }

write() [3/3]

template<class T >

bool tools::wroot::buffer::write ( T  x )

inline

Definition at line 97 of file buffer.

                 {
    if(m_pos+sizeof(T)>m_max) {
      if(!expand2(m_size+sizeof(T))) return false;
    }
    return m_wb.write(x);
  }

write_array() [1/2]

template<class T >

bool tools::wroot::buffer::write_array ( const std::vector< T >  a_v )

inline

Definition at line 154 of file buffer.

                                           {
    if(!write((uint32)a_v.size())) return false;
    return write_fast_array(a_v);
  }

write_array() [2/2]

template<class T >

bool tools::wroot::buffer::write_array ( const T *  a_a, uint32  a_n  )

inline

Definition at line 148 of file buffer.

                                            {
    if(!write(a_n)) return false;
    return write_fast_array(a_a,a_n);
  }

write_array2()

template<class T >

bool tools::wroot::buffer::write_array2 ( const std::vector< std::vector< T > >  a_v )

inline

Definition at line 160 of file buffer.

                                                         {
    if(!write((uint32)a_v.size())) return false;
    for(unsigned int index=0;index<a_v.size();index++) {
      if(!write_array(a_v[index])) return false;
    }
    return true;
  }

write_class()

bool tools::wroot::buffer::write_class ( const std::string &  a_cls )

inlineprotected

Definition at line 349 of file buffer.

                                          {
 
    std::map<std::string,uint32>::const_iterator it = m_clss.find(a_cls);
    if(it!=m_clss.end()) {
      uint32 clIdx = (*it).second;
 
      unsigned int offset = (unsigned int)(m_pos-m_buffer);
 
      // save index of already stored class
      if(!write(uint32(clIdx|kClassMask()))) return false;
 
      m_cls_mapped.push_back(std::pair<uint32,uint32>(offset,clIdx));
 
    } else {
 
      unsigned int offset = (unsigned int)(m_pos-m_buffer);
      if(!write(kNewClassTag())) return false;
      if(!write_cstring(a_cls.c_str())) return false;
      m_clss[a_cls] = offset + kMapOffset();
 
    }
    return true;
  }

write_cstring()

bool tools::wroot::buffer::write_cstring ( const char *  a_s )

inline

Definition at line 125 of file buffer.

{return write_fast_array(a_s,(uint32(::strlen(a_s))+1)*sizeof(char));}

write_fast_array() [1/3]

bool tools::wroot::buffer::write_fast_array ( const char *  a_a, uint32  a_n  )

inline

Definition at line 114 of file buffer.

                                                    {
    if(!a_n) return true;
    uint32 l = a_n * sizeof(char);
    if((m_pos+l)>m_max) {
      if(!expand2(m_size+l)) return false;
    }
    ::memcpy(m_pos,a_a,l);
    m_pos += l;
    return true;
  }

write_fast_array() [2/3]

template<class T >

bool tools::wroot::buffer::write_fast_array ( const std::vector< T > &  a_v )

inline

Definition at line 138 of file buffer.

                                                 {
    if(a_v.empty()) return true;
    uint32 l = uint32(a_v.size() * sizeof(T));
    if((m_pos+l)>m_max) {
      if(!expand2(m_size+l)) return false;
    }
    return m_wb.write<T>(a_v);
  }

write_fast_array() [3/3]

template<class T >

bool tools::wroot::buffer::write_fast_array ( const T *  a_a, uint32  a_n  )

inline

Definition at line 128 of file buffer.

                                                 {
    if(!a_n) return true;
    uint32 l = a_n * sizeof(T);
    if((m_pos+l)>m_max) {
      if(!expand2(m_size+l)) return false;
    }
    return m_wb.write<T>(a_a,a_n);
  }

write_object()

bool tools::wroot::buffer::write_object ( const ibo &  a_obj )

inline

Definition at line 231 of file buffer.

                                     {
    //GB : if adding a write map logic, think to have a displace_mapped()
    //     in basket::write_on_file().
 
    std::map<ibo*,uint32>::const_iterator it = m_objs.find((ibo*)&a_obj);
    if(it!=m_objs.end()) {
 
      uint32 objIdx = (*it).second;
 
      unsigned int offset = (unsigned int)(m_pos-m_buffer);
 
      // save index of already stored object
      if(!write(objIdx)) return false;
 
      m_obj_mapped.push_back(std::pair<uint32,uint32>(offset,objIdx));
 
    } else {
 
      // reserve space for leading byte count
      uint32 cntpos = (unsigned int)(m_pos-m_buffer);
 
      //NOTE : the below test is lacking in CERN-ROOT !
      if((m_pos+sizeof(unsigned int))>m_max) {
        if(!expand2(m_size+sizeof(unsigned int))) return false;
      }
      m_pos += sizeof(unsigned int);
 
      // write class of object first
      if(!write_class(a_obj.store_cls())) return false;
 
      // add to map before writing rest of object (to handle self reference)
      // (+kMapOffset so it's != kNullTag)
      m_objs[(ibo*)&a_obj] = cntpos + kMapOffset();
 
      // let the object write itself :
      if(!a_obj.stream(*this)) return false;
 
      // write byte count
      if(!set_byte_count_obj(cntpos)) return false;
    }
    return true;
  }

write_version() [1/2]

bool tools::wroot::buffer::write_version ( short  a_version )

inline

Definition at line 169 of file buffer.

                                     {
    if(a_version>kMaxVersion()) {
      m_out << "tools::wroot::buffer::write_version :"
            << " version number " << a_version
            << " cannot be larger than " << kMaxVersion() << "."
            << std::endl;
      return false;
    }
    return write(a_version);
  }

write_version() [2/2]

bool tools::wroot::buffer::write_version ( short  a_version, uint32 &  a_pos  )

inline

Definition at line 179 of file buffer.

                                                   {
    // reserve space for leading byte count
    a_pos = (uint32)(m_pos-m_buffer);
 
    //NOTE : the below test is lacking in CERN-ROOT !
    if((m_pos+sizeof(unsigned int))>m_max) {
      if(!expand2(m_size+sizeof(unsigned int))) return false;
    }
    m_pos += sizeof(unsigned int);
 
    if(a_version>kMaxVersion()) {
      m_out << "tools::wroot::buffer::write_version :"
            << " version number " << a_version
            << " cannot be larger than " << kMaxVersion() << "."
            << std::endl;
      return false;
    }
    return write(a_version);
  }

Member Data Documentation

m_buffer

char* tools::wroot::buffer::m_buffer

protected

Definition at line 393 of file buffer.

m_byte_swap

bool tools::wroot::buffer::m_byte_swap

protected

Definition at line 391 of file buffer.

m_cls_mapped

std::vector< std::pair<uint32,uint32> > tools::wroot::buffer::m_cls_mapped

protected

Definition at line 402 of file buffer.

m_clss

std::map<std::string,uint32> tools::wroot::buffer::m_clss

protected

Definition at line 401 of file buffer.

m_max

char* tools::wroot::buffer::m_max

protected

Definition at line 394 of file buffer.

m_obj_mapped

std::vector< std::pair<uint32,uint32> > tools::wroot::buffer::m_obj_mapped

protected

Definition at line 399 of file buffer.

m_objs

std::map<ibo*,uint32> tools::wroot::buffer::m_objs

protected

Definition at line 398 of file buffer.

m_out

std::ostream& tools::wroot::buffer::m_out

protected

Definition at line 390 of file buffer.

m_pos

char* tools::wroot::buffer::m_pos

protected

Definition at line 395 of file buffer.

m_size

uint32 tools::wroot::buffer::m_size

protected

Definition at line 392 of file buffer.

m_wb

wbuf tools::wroot::buffer::m_wb

protected

Definition at line 396 of file buffer.

---

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

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/wroot/buffer