tools::rroot::basket Class Reference

Inheritance diagram for tools::rroot::basket:

Collaboration diagram for tools::rroot::basket:

Public Member Functions
virtual void *	cast (const std::string &a_class) const
virtual const std::string &	s_cls () const
virtual void *	cast (cid a_class) const
virtual iro *	copy () const
virtual bool	stream (buffer &a_buffer)
	basket (std::ostream &a_out)
	basket (std::ostream &a_out, seek a_pos, uint32 a_nbytes)
virtual	~basket ()
	basket (const basket &a_from)
basket &	operator= (const basket &a_from)
int *	entry_offset ()
int *	displacement ()
uint32	nev_buf_size () const
uint32	nev () const
uint32	last () const
bool	read_offset_tables (bool a_byte_swap)
Public Member Functions inherited from tools::rroot::iro
virtual	~iro ()
Public Member Functions inherited from tools::rroot::key
	key (std::ostream &a_out)
	key (std::ostream &a_out, seek a_pos, uint32 a_nbytes)
virtual	~key ()
key &	operator= (const key &a_from)
std::ostream &	out () const
uint32	nbytes () const
seek	seek_key () const
uint32	object_size () const
const std::string &	object_name () const
const std::string &	object_title () const
const std::string &	object_class () const
bool	read_file (ifile &a_file)
char *	buf () const
char *	data_buffer () const
const char *	eob () const
uint32	buf_size () const
uint32	key_length () const
bool	from_buffer (bool a_byte_swap, const char *aEOB, char *&a_pos, bool a_verbose)
char *	get_object_buffer (ifile &a_file, uint32 &a_size)
void	dump (std::ostream &a_out) const

Static Public Member Functions
static const std::string &	s_class ()
static cid	id_class ()
Static Public Member Functions inherited from tools::rroot::key
static uint32	std_string_record_size (const std::string &x)

Protected Member Functions
void	_clear ()
Protected Member Functions inherited from tools::rroot::key
	key (const key &a_from)
uint32	record_size (uint32 a_version) const
bool	unzip (std::ostream &a_out, ifile &a_file, int a_srcsize, unsigned char *a_src, int a_tgtsize, unsigned char *a_tgt, int &a_irep)

Protected Attributes
uint32	m_nev_buf_size
uint32	m_nev
uint32	m_last
int *	m_entry_offset
int *	m_displacement
Protected Attributes inherited from tools::rroot::key
std::ostream &	m_out
uint32	m_buf_size
char *	m_buffer
uint32	m_nbytes
uint32	m_version
uint32	m_object_size
date	m_date
uint16	m_key_length
uint16	m_cycle
seek	m_seek_key
seek	m_seek_parent_dir
std::string	m_object_class
std::string	m_object_name
std::string	m_object_title

Additional Inherited Members
Static Protected Member Functions inherited from tools::rroot::key
static const std::string &	s_class ()
Static Protected Attributes inherited from tools::rroot::key
static const uint32	START_BIG_FILE = 2000000000

Detailed Description

Definition at line 17 of file basket.

Constructor & Destructor Documentation

basket() [1/3]

tools::rroot::basket::basket ( std::ostream &  a_out )

inline

Definition at line 186 of file basket.

  :parent(a_out)
  ,m_nev_buf_size(0)
  ,m_nev(0)
  ,m_last(0)
  ,m_entry_offset(0)
  ,m_displacement(0)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }

basket() [2/3]

tools::rroot::basket::basket ( std::ostream &  a_out, seek  a_pos, uint32  a_nbytes  )

inline

Definition at line 198 of file basket.

  :parent(a_out,a_pos,a_nbytes)
  ,m_nev_buf_size(0)
  ,m_nev(0)
  ,m_last(0)
  ,m_entry_offset(0)
  ,m_displacement(0)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }

~basket()

virtual tools::rroot::basket::~basket ( )

inlinevirtual

Definition at line 210 of file basket.

                   {
    _clear();
#ifdef TOOLS_MEM
    mem::decrement(s_class().c_str());
#endif
  }

basket() [3/3]

tools::rroot::basket::basket ( const basket &  a_from )

inline

Definition at line 217 of file basket.

  :iro(a_from)
  ,parent(a_from)
  ,m_nev_buf_size(a_from.m_nev_buf_size)
  ,m_nev(a_from.m_nev)
  ,m_last(a_from.m_last)
  ,m_entry_offset(0)
  ,m_displacement(0)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
    if(a_from.m_nev && a_from.m_entry_offset) {
      m_entry_offset = new int[a_from.m_nev];
      if(!m_entry_offset) {
        m_out << "tools::rroot::basket::basket(cpcstor) :"
                     << " can't alloc " << a_from.m_nev << "."
                     << std::endl;
      } else {
        uint32 len = a_from.m_nev*sizeof(int);
        ::memcpy(m_entry_offset,a_from.m_entry_offset,len);
      }
    }
    if(a_from.m_nev && a_from.m_displacement) {
      m_displacement = new int[a_from.m_nev];
      if(!m_displacement) {
        m_out << "tools::rroot::basket::basket(cpcstor) :"
                     << " can't alloc " << a_from.m_nev << "."
                     << std::endl;
      } else {
        uint32 len = a_from.m_nev*sizeof(int);
        ::memcpy(m_displacement,a_from.m_displacement,len);
      }
    }
  }

Member Function Documentation

_clear()

void tools::rroot::basket::_clear ( )

inlineprotected

Definition at line 350 of file basket.

               {
    delete [] m_entry_offset;
    delete [] m_displacement;
    m_entry_offset = 0;
    m_displacement = 0;
  }

cast() [1/2]

virtual void* tools::rroot::basket::cast ( cid  a_class ) const

inlinevirtual

Implements tools::rroot::iro.

Definition at line 33 of file basket.

                                        {
    if(void* p = cmp_cast<basket>(this,a_class)) {return p;}
    else return 0;
  }

cast() [2/2]

virtual void* tools::rroot::basket::cast ( const std::string &  a_class ) const

inlinevirtual

Implements tools::rroot::iro.

Definition at line 26 of file basket.

                                                     {
    if(void* p = cmp_cast<basket>(this,a_class)) return p;
    return 0;
  }

copy()

virtual iro* tools::rroot::basket::copy ( ) const

inlinevirtual

Implements tools::rroot::iro.

Definition at line 38 of file basket.

{return new basket(*this);}

displacement()

int* tools::rroot::basket::displacement ( )

inline

Definition at line 293 of file basket.

{return m_displacement;}

entry_offset()

int* tools::rroot::basket::entry_offset ( )

inline

Definition at line 292 of file basket.

{return m_entry_offset;}

id_class()

static cid tools::rroot::basket::id_class ( )

inlinestatic

Definition at line 32 of file basket.

{return basket_cid();}

last()

uint32 tools::rroot::basket::last ( ) const

inline

Definition at line 296 of file basket.

{return m_last;}

nev()

uint32 tools::rroot::basket::nev ( ) const

inline

Definition at line 295 of file basket.

{return m_nev;}

nev_buf_size()

uint32 tools::rroot::basket::nev_buf_size ( ) const

inline

Definition at line 294 of file basket.

{return m_nev_buf_size;}

operator=()

basket& tools::rroot::basket::operator= ( const basket &  a_from )

inline

Definition at line 252 of file basket.

                                         {
    parent::operator=(a_from);
 
    if(&a_from==this) return *this;
 
    m_nev_buf_size = a_from.m_nev_buf_size;
    m_nev = a_from.m_nev;
    m_last = a_from.m_last;
 
    delete [] m_entry_offset;
    m_entry_offset = 0;
    delete [] m_displacement;
    m_displacement = 0;
 
    if(a_from.m_nev && a_from.m_entry_offset) {
      m_entry_offset = new int[a_from.m_nev];
      if(!m_entry_offset) {
        m_out << "tools::rroot::basket::operator=() :"
                     << " can't alloc " << a_from.m_nev << "."
                     << std::endl;
      } else {
        uint32 len = a_from.m_nev*sizeof(int);
        ::memcpy(m_entry_offset,a_from.m_entry_offset,len);
      }
    }
    if(a_from.m_nev && a_from.m_displacement) {
      m_displacement = new int[a_from.m_nev];
      if(!m_displacement) {
        m_out << "tools::rroot::basket::operator=() :"
                     << " can't alloc " << a_from.m_nev << "."
                     << std::endl;
      } else {
        uint32 len = a_from.m_nev*sizeof(int);
        ::memcpy(m_displacement,a_from.m_displacement,len);
      }
    }
 
    return *this;
  }

read_offset_tables()

bool tools::rroot::basket::read_offset_tables ( bool  a_byte_swap )

inline

Definition at line 298 of file basket.

                                            {
    if(!m_buffer) return false;
    if(!m_last) return false;
 
    delete [] m_entry_offset;
    m_entry_offset = 0;
 
    buffer _buffer(m_out,a_byte_swap,m_buf_size,m_buffer,0,false);
    _buffer.set_offset(m_last);
 
   {uint32 n;
    if(!_buffer.read_array<int>(0,m_entry_offset,n)) {
      m_out << "tools::rroot::basket::read_offset_tables :"
                   << " read_array failed."
                   << std::endl;
      return false;
    }
    if((n!=m_nev)&&(n!=(m_nev+1))) {
      m_out << "tools::rroot::basket::read_offset_tables :"
                   << " m_entry_offset read len mismatch."
                   << " n " << n
                   << " m_nev " << m_nev
                   << std::endl;
      return false;
    }}
 
    delete [] m_displacement;
    m_displacement = 0;
    if(_buffer.length()!=_buffer.size()) {
      // There is more data in the buffer!  It is the diplacement
      // array.
      uint32 n;
      if(!_buffer.read_array<int>(0,m_displacement,n)) {
        m_out << "tools::rroot::basket::read_offset_tables :"
                     << " readArray(2) failed."
                     << std::endl;
        return false;
      }
      if((n!=m_nev)&&(n!=(m_nev+1))) {
        m_out << "tools::rroot::basket::read_offset_tables :"
                     << " m_displacement read len mismatch."
                     << " n " << n
                     << " m_nev " << m_nev
                     << std::endl;
        return false;
      }
    }
 
    return true;
  }

s_class()

static const std::string& tools::rroot::basket::s_class ( )

inlinestatic

Definition at line 21 of file basket.

                                    {
    static const std::string s_v("tools::rroot::basket");
    return s_v;
  }

s_cls()

virtual const std::string& tools::rroot::basket::s_cls ( ) const

inlinevirtual

Implements tools::rroot::iro.

Definition at line 30 of file basket.

{return s_class();}

stream()

virtual bool tools::rroot::basket::stream ( buffer &  a_buffer )

inlinevirtual

Implements tools::rroot::iro.

Definition at line 39 of file basket.

                                        {
    _clear();
 
    uint32 startpos = a_buffer.length();
 
    if(!parent::from_buffer(a_buffer.byte_swap(),a_buffer.eob(),a_buffer.pos(),a_buffer.verbose())) return false;
 
    uint32 fBufferSize;
 
    short v;
    if(!a_buffer.read_version(v)) return false;
    if(!a_buffer.read(fBufferSize)) return false;
    if(!a_buffer.read(m_nev_buf_size)) return false;
    if(!a_buffer.read(m_nev)) return false;
    if(!a_buffer.read(m_last)) return false;
    char flag;
    if(!a_buffer.read(flag)) return false;
    if(m_last>fBufferSize) fBufferSize = m_last;
 
    uint16 basket_key_length = a_buffer.length()-startpos;
    if(basket_key_length!=m_key_length) {
      //m_out << "tools::rroot::basket::stream :"
      //             << " key length not consistent."
      //             << " read " << m_key_length
      //             << ", expected " << basket_key_length
      //             << ". Continue with " << basket_key_length
      //             << std::endl;
      m_key_length = basket_key_length;
    }
    if(!m_object_size) {
      //m_out << "tools::rroot::basket::stream :"
      //             << " m_object_size is found to be zero."
      //             << " Continue with (m_nbytes-m_key_length) "
      //             << (m_nbytes-m_key_length)
      //             << std::endl;
      m_object_size = m_nbytes-m_key_length;
    }
 
    if(!flag) return true; //fHeaderOnly
 
    //G.Barrand : add the below test.
    if( (flag!=1) &&(flag!=2)  &&
        (flag!=11)&&(flag!=12) &&
        (flag!=41)&&(flag!=42) &&
        (flag!=51)&&(flag!=52) ) {
      m_out << "tools::rroot::basket::stream :"
                   << " bad flag " << (int)flag
                   << std::endl;
      return false;
    }
 
    if((flag%10)!=2) {
      //due to the upper "G.Barrand if", flag is here in {1,11,41,51}
 
      if(!m_nev_buf_size) {
        m_out << "tools::rroot::basket::stream :"
                     << " m_nev_buf_size is zero." << std::endl;
        return false;
      }
      if(m_nev>m_nev_buf_size) {
        m_out << "tools::rroot::basket::stream :"
                     << " m_nev>m_nev_buf_size !"
                     << " m_nev " << m_nev
                     << " m_nev_buf_size " << m_nev_buf_size
                     << std::endl;
        return false;
      }
      m_entry_offset = new int[m_nev_buf_size];
      if(m_nev) {
        uint32 n;
        if(!a_buffer.read_array<int>(m_nev_buf_size,m_entry_offset,n)) {
          _clear();
          return false;
        }
        if((n!=m_nev)&&(n!=(m_nev+1))) {
          m_out << "tools::rroot::basket::stream :"
                       << " m_entry_offset read len mismatch."
                       << " n " << n
                       << " m_nev " << m_nev
                       << std::endl;
          _clear();
          return false;
        }
      }
/* Due to the upper "G.Barrand if", flag can't be in ]20,40[, then to quiet Coverity we comment the below test.
      if((20<flag)&&(flag<40)) {
        for(uint32 i=0;i<m_nev;i++){
          m_entry_offset[i] &= ~kDisplacementMask();
        }
      }
*/
      if(flag>40) {
        m_displacement = new int[m_nev_buf_size];
        uint32 n;
        if(!a_buffer.read_array<int>(m_nev_buf_size,m_displacement,n)) {
          _clear();
          return false;
        }
        if((n!=m_nev)&&(n!=(m_nev+1))) {
          m_out << "tools::rroot::basket::stream :"
                       << " m_displacement read len mismatch."
                       << " n " << n
                       << " m_nev " << m_nev
                       << std::endl;
          _clear();
          return false;
        }
      }
    } else {
      //m_nev_buf_size is the size in bytes of one entry.
    }
    if((flag==1)||(flag>10)) {
      delete [] m_buffer;
      m_buffer = 0;
      m_buf_size = 0;
      if(fBufferSize) {
        char* _buf = new char[fBufferSize];
        if(!_buf) {
          m_out << "tools::rroot::basket::stream :"
                       << " can't alloc " << fBufferSize << std::endl;
          _clear();
          return false;
        }
        if(v>1) {
          if(!a_buffer.read_fast_array(_buf,m_last)) {
            _clear();
            delete [] _buf;
            return false;
          }
        } else {
          uint32 n;
          if(!a_buffer.read_array<char>(fBufferSize,_buf,n)) {
            _clear();
            delete [] _buf;
            return false;
          }
        }
        m_buffer = _buf;
        m_buf_size = fBufferSize;
        //fBufferRef->inline_setBufferOffset(m_last);
        //fBranch.tree().incrementTotalBuffers(fBufferSize);
      }
    }
 
    return true;
  }

Member Data Documentation

m_displacement

int* tools::rroot::basket::m_displacement

protected

Definition at line 361 of file basket.

m_entry_offset

int* tools::rroot::basket::m_entry_offset

protected

Definition at line 360 of file basket.

m_last

uint32 tools::rroot::basket::m_last

protected

Definition at line 359 of file basket.

m_nev

uint32 tools::rroot::basket::m_nev

protected

Definition at line 358 of file basket.

m_nev_buf_size

uint32 tools::rroot::basket::m_nev_buf_size

protected

Definition at line 357 of file basket.

---

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

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/rroot/basket