Inheritance diagram for tools::wroot::basket:

Collaboration diagram for tools::wroot::basket:

[legend]

Public Member Functions
virtual const std::string &	store_cls () const

virtual bool	stream (buffer &a_buffer) const

	basket (std::ostream &a_out, bool a_byte_swap, seek a_seek_directory, const std::string &a_object_name, const std::string &a_object_title, const std::string &a_object_class, uint32 a_basket_size, bool a_verbose)

virtual	~basket ()

const buffer &	datbuf () const

buffer &	datbuf ()

const int *	entry_offset () const

int *	entry_offset ()

const int *	displacement () const

int *	displacement ()

uint32	nev_buf_size () const

uint32	nev () const

uint32	last () const

void	set_nev (uint32 a_last, uint32 a_nev_buf_size, uint32 a_nev, const int a_entry_offset, const int a_displacement)

bool	update (uint32 a_offset)

bool	write_on_file (ifile &a_file, uint16 a_cycle, uint32 &a_nbytes)

Public Member Functions inherited from tools::wroot::ibo
virtual	~ibo ()

Public Member Functions inherited from tools::wroot::key
	key (std::ostream &a_out, seek a_seek_directory, const std::string &a_object_name, const std::string &a_object_title, const std::string &a_object_class)

	key (std::ostream &a_out, ifile &a_file, seek a_seek_directory, const std::string &a_object_name, const std::string &a_object_title, const std::string &a_object_class, uint32 a_object_size)

virtual	~key ()

uint16	cycle () const

void	set_cycle (uint16 a_cycle)

const std::string &	object_name () const

const std::string &	object_title () const

const std::string &	object_class () const

bool	write_self (ifile &a_file)

bool	write_file (ifile &a_file, uint32 &a_nbytes)

void	set_number_of_bytes (uint32 a_n)

uint32	number_of_bytes () const

uint32	object_size () const

seek	seek_key () const

short	key_length () const

char *	data_buffer ()

const char *	eob () const

bool	to_buffer (wbuf &a_wb, bool a_verbose) const

Static Public Member Functions
static const std::string &	s_class ()

Static Public Member Functions inherited from tools::wroot::key
static unsigned int	std_string_record_size (const std::string &x)

Protected Member Functions
	basket (const basket &a_from)

basket &	operator= (const basket &a_from)

uint32	header_record_size (uint32 a_version) const

bool	_stream_header (buffer &a_buffer, bool a_verbose, char a_flag=0) const

Protected Member Functions inherited from tools::wroot::key
	key (const key &a_from)

key &	operator= (const key &)

uint32	record_size (uint32 a_version) const

bool	initialize_zero ()

bool	initialize (ifile &a_file, uint32 a_nbytes)

Protected Attributes
bool	m_verbose

buffer	m_data

uint32	m_nev_buf_size

uint32	m_nev

uint32	m_last

int *	m_entry_offset

int *	m_displacement

Protected Attributes inherited from tools::wroot::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_directory

std::string	m_object_class

std::string	m_object_name

std::string	m_object_title

Detailed Description

Definition at line 14 of file basket.

Constructor & Destructor Documentation

◆ basket() [1/2]

tools::wroot::basket::basket	(	std::ostream &	a_out,
		bool	a_byte_swap,
		seek	a_seek_directory,
		const std::string &	a_object_name,
		const std::string &	a_object_title,
		const std::string &	a_object_class,
		uint32	a_basket_size,
		bool	a_verbose
	)

inline

Definition at line 104 of file basket.

   :parent(a_out,a_seek_directory,a_object_name,a_object_title,a_object_class)
   ,m_verbose(a_verbose)
   ,m_data(a_out,a_byte_swap,a_basket_size)
   ,m_nev_buf_size(1000)
   ,m_nev(0)
   ,m_last(0)
   ,m_entry_offset(0)
   ,m_displacement(0)
   {
 #ifdef TOOLS_MEM
     mem::increment(s_class().c_str());
 #endif
  
     if(m_version>big_file_version_tag()) {
     } else {
       // G.Barrand : April 2016 : WARNING : this is a change in the ROOT/IO format compared to CERN-ROOT/4.x :
       // We follow the logic found on CERN-ROOT/5.x that enforces "+1000" on all baskets.
       m_version += big_file_version_tag();
     }
  
     m_key_length = header_record_size(m_version);
     initialize_zero();
  
     if(m_nev_buf_size) {
       m_entry_offset = new int[m_nev_buf_size];
      {for(uint32 i=0;i<m_nev_buf_size;i++) m_entry_offset[i] = 0;}
     }
   }

◆ ~basket()

virtual tools::wroot::basket::~basket ( )

inlinevirtual

Definition at line 139 of file basket.

                    {
     delete [] m_entry_offset;
     delete [] m_displacement;
     m_entry_offset = 0;
     m_displacement = 0;
 #ifdef TOOLS_MEM
     mem::decrement(s_class().c_str());
 #endif
   }

◆ basket() [2/2]

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

inlineprotected

Definition at line 149 of file basket.

   :ibo(a_from)
   ,parent(a_from)
   ,m_verbose(a_from.m_verbose)
   ,m_data(m_out,a_from.m_data.byte_swap(),256)
   ,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
   }

Member Function Documentation

◆ _stream_header()

bool tools::wroot::basket::_stream_header	(	buffer &	a_buffer,
		bool	a_verbose,
		char	a_flag = `0`
	)		const

inlineprotected

Definition at line 365 of file basket.

                                                                              {
    {uint32 l = parent::record_size(m_version);
     if((a_buffer.length()+l)>a_buffer.size()) {
       if(!a_buffer.expand(a_buffer.size()+l)) return false;
     }
     wbuf wb(m_out,a_buffer.byte_swap(),a_buffer.max_pos(),a_buffer.pos());
     if(!parent::to_buffer(wb,a_verbose)) return false;}
  
     if(!a_buffer.write_version(2)) return false;
     if(!a_buffer.write(m_buf_size)) return false;
     if(!a_buffer.write(m_nev_buf_size)) return false;
     if(!a_buffer.write(m_nev)) return false;
     if(!a_buffer.write(m_last)) return false;
     if(!a_buffer.write(a_flag)) return false;
     return true;
   }

◆ datbuf() [1/2]

buffer& tools::wroot::basket::datbuf ( )

inline

Definition at line 173 of file basket.

173 {return m_data;}

◆ datbuf() [2/2]

const buffer& tools::wroot::basket::datbuf ( ) const

inline

Definition at line 172 of file basket.

172 {return m_data;}

◆ displacement() [1/2]

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

inline

Definition at line 179 of file basket.

179 {return m_displacement;}

◆ displacement() [2/2]

const int* tools::wroot::basket::displacement ( ) const

inline

Definition at line 178 of file basket.

178 {return m_displacement;}

◆ entry_offset() [1/2]

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

inline

Definition at line 176 of file basket.

176 {return m_entry_offset;}

◆ entry_offset() [2/2]

const int* tools::wroot::basket::entry_offset ( ) const

inline

Definition at line 175 of file basket.

175 {return m_entry_offset;}

◆ header_record_size()

uint32 tools::wroot::basket::header_record_size ( uint32 a_version ) const

inlineprotected

Definition at line 352 of file basket.

                                                     {
     // header only.
     uint32 nbytes = parent::record_size(a_version);
  
     nbytes += sizeof(short);   //version
     nbytes += sizeof(uint32); //m_buf_size
     nbytes += sizeof(uint32); //m_nev_buf_size
     nbytes += sizeof(uint32); //m_nev
     nbytes += sizeof(uint32); //m_last
     nbytes += sizeof(char);   //flag
  
     return nbytes;
   }

◆ last()

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

inline

Definition at line 183 of file basket.

183 {return m_last;}

◆ nev()

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

inline

Definition at line 182 of file basket.

182 {return m_nev;}

◆ nev_buf_size()

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

inline

Definition at line 181 of file basket.

181 {return m_nev_buf_size;}

◆ operator=()

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

inlineprotected

Definition at line 164 of file basket.

                                          {
     parent::operator=(a_from);
     m_nev_buf_size = a_from.m_nev_buf_size;
     m_nev = a_from.m_nev;
     m_last = a_from.m_last;
     return *this;
   }

◆ s_class()

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

inlinestatic

Definition at line 17 of file basket.

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

◆ set_nev()

void tools::wroot::basket::set_nev	(	uint32	a_last,
		uint32	a_nev_buf_size,
		uint32	a_nev,
		const int *	a_entry_offset,
		const int *	a_displacement
	)

inline

Definition at line 185 of file basket.

                                                                                                                      {
     m_last = a_last;
     m_nev_buf_size = a_nev_buf_size;
     m_nev = a_nev;
     delete [] m_entry_offset;
     m_entry_offset = 0;
     delete [] m_displacement;
     m_displacement = 0;
  
     if(a_entry_offset && m_nev_buf_size) {
       m_entry_offset = new int[m_nev_buf_size];
       for(uint32 i=0;i<m_nev;i++) m_entry_offset[i] = a_entry_offset[i];
     }
  
     if(a_displacement && m_nev_buf_size) {
       m_displacement = new int[m_nev_buf_size];
       for(uint32 i=0;i<m_nev;i++) m_displacement[i] = a_displacement[i];
     }
   }

◆ store_cls()

virtual const std::string& tools::wroot::basket::store_cls ( ) const

inlinevirtual

Implements tools::wroot::ibo.

Definition at line 22 of file basket.

                                              {
     static const std::string s_v("TBasket");
     return s_v;
   }

◆ stream()

virtual bool tools::wroot::basket::stream ( buffer & a_buffer ) const

inlinevirtual

Implements tools::wroot::ibo.

Definition at line 26 of file basket.

                                               {
     // in principle we pass here only for the last basket
     // of a branch when it is streamed from branch::stream().
  
     // We pass also here in the case of filling "tree in a tree" (MEMPHYS sim).
  
     // some consitency checks :
     //G.Barrand : the below test is "too much". Someone
     //            may have to write a tree (and then a basket)
     //            which had been never filled.
     //            Moreover with the today branch code, a
     //              basket.write_on_file()
     //            happens only in a branch.fill() that deletes
     //            the basket just after the call.
   //if(!m_data.length()) {
   //  // to be sure to not work on a basket already written
   //  // with write_on_file()
   //  m_out << "tools::wroot::basket::stream :"
   //        << " m_data.length() is null."
   //        << std::endl;
   //  return false;
   //}
     if(m_seek_key) {
       m_out << "tools::wroot::basket::stream :"
             << " m_seek_key is not null (" << m_seek_key << ")."
             << std::endl;
       return false;
     }
     if(m_last) {
       m_out << "tools::wroot::basket::stream :"
             << " m_last is not null."
             << std::endl;
       return false;
     }
     if(!m_entry_offset) {
       m_out << "tools::wroot::basket::stream :"
             << " m_entry_offset is null."
             << std::endl;
       return false;
     }
  
    {uint32 _last = m_data.length()+m_key_length;
     if(_last>m_last) {
       const_cast<basket&>(*this).m_last = _last;
     }}
     if(m_last>m_buf_size) {
       const_cast<basket&>(*this).m_buf_size = m_last;
     }
  
     char flag = 11;
     if(m_displacement)  flag += 40;
     if(!_stream_header(a_buffer,m_verbose,flag)) return false;
  
     if(m_entry_offset && m_nev) {
       if(!a_buffer.write_array(m_entry_offset,m_nev)) return false;
       if(m_displacement) {
         if(!a_buffer.write_array(m_displacement,m_nev)) return false;
       }
     }
  
     if(m_data.to_displace()) {
       if(!const_cast<basket&>(*this).m_data.displace_mapped(m_key_length)) {
         m_out << "tools::wroot::basket::stream :"
               << " m_data.displace_mapped() failed."
               << std::endl;
         return false;
       }
     }
  
     buffer bref(m_out,a_buffer.byte_swap(),256);
     if(!_stream_header(bref,m_verbose)) return false; //then header stored twice !
     //if(bref.length()!=m_key_length) {}
     if(!bref.write_fast_array(m_data.buf(),m_data.length())) return false;
     if(!a_buffer.write_fast_array(bref.buf(),bref.length())) return false;
  
     return true;
   }

◆ update()

bool tools::wroot::basket::update ( uint32 a_offset )

inline

Definition at line 205 of file basket.

                                {
     if(m_entry_offset) {
       if((m_nev+1)>=m_nev_buf_size) { // for the +1, we follow CERN-ROOT/TBasket logic that wants to store
                                       // nev+1 elements for m_entry_offset in the write_on_file() method.
         uint32 newsize = mx<uint32>(10,2*m_nev_buf_size);
         if(!realloc<int>(m_entry_offset,newsize,m_nev_buf_size,true)){
           m_out << "tools::wroot::basket::update : realloc failed." << std::endl;
           return false;
         }
         if(m_displacement) {
           if(!realloc<int>(m_displacement,newsize,m_nev_buf_size,true)){
             m_out << "tools::wroot::basket::update : realloc failed." << std::endl;
             return false;
           }
         }
         m_nev_buf_size = newsize;
       }
       m_entry_offset[m_nev] = (int)a_offset;
     }
     m_nev++;
     return true;
   }

◆ write_on_file()

bool tools::wroot::basket::write_on_file	(	ifile &	a_file,
		uint16	a_cycle,
		uint32 &	a_nbytes
	)

inline

Definition at line 228 of file basket.

                                                                     {
     // write m_data buffer into file.
     //NOTE : m_data does not contain the key at its head.
     //       At this point m_seek_key should be 0.
  
     a_nbytes = 0;
  
     if(m_seek_key) {
       m_out << "tools::wroot::basket::write_on_file :"
             << " m_seek_key should be 0 (" << m_seek_key << ")."
             << std::endl;
       return false;
     }
  
     if(m_version>big_file_version_tag()) {
     } else {
       m_out << "tools::wroot::basket::write_on_file : "
             << " we should not pass here (1)."
             << std::endl;
       return false;
 /*
       if(a_file.END()>START_BIG_FILE()) {
         //GB : enforce m_version>big_file_version_tag() if m_version is still 2 but
         //     seek_key>START_BIG_FILE. If not doing that we shall
         //     write a big m_seek_key on a seek32 and then have
         //     a problem when reading.
  
         //m_out << "tools::wroot::basket::write_on_file : "
         //      << " WARNING : pos>START_BIG_FILE."
         //      << std::endl;
  
         m_version += big_file_version_tag();
         m_key_length += 8;
  
         if(m_entry_offset) {
           for(uint32 i=0;i<m_nev;i++) m_entry_offset[i] += 8;
           if(m_displacement) {
             //??? Do we have to shift them ?
             m_out << "tools::wroot::basket::write_on_file : "
                   << " displace logic : m_displacement not null."
                   << std::endl;
           }
         }
  
       }
 */
     }
  
     // Transfer m_entry_offset table at the end of fBuffer. Offsets to fBuffer
     // are transformed in entry length to optimize compression algorithm.
     m_last = m_key_length+m_data.length();
     if(m_entry_offset) {
       if(!m_data.write_array<int>(m_entry_offset,m_nev+1)) { // for the +1 we follow CERN-ROOT/TBasket logic.
         delete [] m_entry_offset;
         m_entry_offset = 0;
         return false;
       }
       delete [] m_entry_offset;
       m_entry_offset = 0;
       if(m_displacement) {
         if(!m_data.write_array<int>(m_displacement,m_nev+1)) {
           delete [] m_displacement;
           m_displacement = 0;
           return false;
         }
         delete [] m_displacement;
         m_displacement = 0;
       }
     }
  
     m_object_size = m_data.length(); //uncompressed size.
  
     m_cycle = a_cycle;
  
     if(!m_data.displace_mapped(m_key_length)) return false;
  
     char* kbuf = 0;
     uint32 klen = 0;
     bool kdelete = false;
     a_file.compress_buffer(m_data,kbuf,klen,kdelete);
  
     if(klen>m_object_size) {
       m_out << "tools::wroot::basket::write_on_file :"
             << " compression anomaly "
             << " m_object_size " << m_object_size
             << " klen " << klen
             << std::endl;
       if(kdelete) delete [] kbuf;
       return false;
     }
  
     if(!initialize(a_file,klen)) { //it will do a m_seek_key = a_file.END() and then a_file.set_END(...)
       m_out << "tools::wroot::basket::write_on_file :"
             << " initialize() failed."
             << std::endl;
       if(kdelete) delete [] kbuf;
       return false;
     }
  
     //write header of the key :
    {buffer bref(m_out,a_file.byte_swap(),256);
     if(!_stream_header(bref,a_file.verbose())) return false;
     if(bref.length()!=m_key_length) {
       m_out << "tools::wroot::basket::write_on_file :"
             << " key len anomaly " << bref.length()
             << " m_key_length " << m_key_length
             << std::endl;
       if(kdelete) delete [] kbuf;
       return false;
     }
     ::memcpy(m_buffer,bref.buf(),m_key_length);}
  
     ::memcpy(m_buffer+m_key_length,kbuf,klen);
     if(kdelete) delete [] kbuf;
  
     uint32 nbytes;
     if(!parent::write_file(a_file,nbytes)) return false;
  
     m_data.pos() = m_data.buf(); //empty m_data.
  
     a_nbytes = m_key_length + klen;
     return true;
   }

Member Data Documentation

◆ m_data

buffer tools::wroot::basket::m_data

protected

Definition at line 383 of file basket.

◆ m_displacement

int* tools::wroot::basket::m_displacement

protected

Definition at line 389 of file basket.

◆ m_entry_offset

int* tools::wroot::basket::m_entry_offset

protected

Definition at line 388 of file basket.

◆ m_last

uint32 tools::wroot::basket::m_last

protected

Definition at line 387 of file basket.

◆ m_nev

uint32 tools::wroot::basket::m_nev

protected

Definition at line 386 of file basket.

◆ m_nev_buf_size

uint32 tools::wroot::basket::m_nev_buf_size

protected

Definition at line 385 of file basket.

◆ m_verbose

bool tools::wroot::basket::m_verbose

protected

Definition at line 382 of file basket.

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

/Users/barrand/private/dev/softinex/g4tools/g4tools/tools/wroot/basket

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ basket() [1/2]

◆ ~basket()

◆ basket() [2/2]

Member Function Documentation

◆ _stream_header()

◆ datbuf() [1/2]

◆ datbuf() [2/2]

◆ displacement() [1/2]

◆ displacement() [2/2]

◆ entry_offset() [1/2]

◆ entry_offset() [2/2]

◆ header_record_size()

◆ last()

◆ nev()

◆ nev_buf_size()

◆ operator=()

◆ s_class()

◆ set_nev()

◆ store_cls()

◆ stream()

◆ update()

◆ write_on_file()

Member Data Documentation

◆ m_data

◆ m_displacement

◆ m_entry_offset

◆ m_last

◆ m_nev

◆ m_nev_buf_size

◆ m_verbose