Inheritance diagram for inlib::wroot::basket:

Collaboration diagram for inlib::wroot::basket:

Public Member Functions
virtual const std::string &	store_cls () const
virtual bool	stream (buffer &a_buffer) const
	basket (ifile &a_file, seek a_seek_parent_dir, const std::string &a_object_name, const std::string &a_object_title, const std::string &a_object_class, uint32 a_basket_size)
virtual	~basket ()
buffer &	datbuf ()
bool	update (uint32 a_offset)
bool	write_on_file (uint16 a_cycle, uint32 &a_nbytes)
Static Public Member Functions
static const std::string &	s_class ()
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, char a_flag=0) const
Protected Attributes
buffer	m_data
uint32	m_nev_buf_size
uint32	m_nev
uint32	m_last
uint32 *	m_entry_offset
int *	m_displacement

Detailed Description

Definition at line 14 of file basket.

Constructor & Destructor Documentation

inlib::wroot::basket::basket	(	ifile &	a_file,
		seek	a_seek_parent_dir,
		const std::string &	a_object_name,
		const std::string &	a_object_title,
		const std::string &	a_object_class,
		uint32	a_basket_size
	)		`[inline]`

Definition at line 95 of file basket.

  :key(a_file,a_seek_parent_dir,
       a_object_name,a_object_title,a_object_class,0)
  ,m_data(a_file.out(),a_file.byte_swap(),a_basket_size)
  ,m_nev_buf_size(1000)
  ,m_nev(0)
  ,m_last(0)
  ,m_entry_offset(0)
  ,m_displacement(0)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif

    m_key_length = header_record_size(m_version);
    initialize(0);

    if(m_nev_buf_size) m_entry_offset = new uint32[m_nev_buf_size];
  }

virtual inlib::wroot::basket::~basket ( ) [inline, virtual]

Definition at line 119 of file basket.

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

inlib::wroot::basket::basket ( const basket & a_from ) [inline, protected]

Definition at line 129 of file basket.

  : ibo(a_from)
  ,key(a_from)
  ,m_data(m_file.out(),m_file.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 INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }

Member Function Documentation

bool inlib::wroot::basket::_stream_header	(	buffer &	a_buffer,
		char	a_flag = `0`
	)		const `[inline, protected]`

Definition at line 324 of file basket.

                                                              {
   {uint32 l = key::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_file.out(),m_file.byte_swap(),a_buffer.max_pos(),a_buffer.pos());
    if(!key::to_buffer(wb)) 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;
  }

buffer& inlib::wroot::basket::datbuf ( ) [inline]

Definition at line 151 of file basket.

{return m_data;}

uint32 inlib::wroot::basket::header_record_size ( uint32 a_version ) const [inline, protected]

Definition at line 311 of file basket.

                                                    {
    // header only.
    uint32 nbytes = key::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;
  }

basket& inlib::wroot::basket::operator= ( const basket & a_from ) [inline, protected]

Definition at line 143 of file basket.

                                         {
    key::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;
  }

static const std::string& inlib::wroot::basket::s_class ( ) [inline, static]

Reimplemented from inlib::wroot::key.

Definition at line 17 of file basket.

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

virtual const std::string& inlib::wroot::basket::store_cls ( ) const [inline, virtual]

Implements inlib::wroot::ibo.

Definition at line 22 of file basket.

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

virtual bool inlib::wroot::basket::stream ( buffer & a_buffer ) const [inline, virtual]

Implements inlib::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().

    // some consitency checks :
    if(!m_data.length()) {
      // to be sure to not work on a basket already written
      // with write_on_file()
      m_file.out() << "inlib::wroot::basket::stream :" 
                   << " m_data.length() is null."
                   << std::endl;
      return false;
    }
    if(m_seek_key) {
      m_file.out() << "inlib::wroot::basket::stream :" 
                   << " m_seek_key is not null."
                   << std::endl;
      return false;
    }
    if(m_last) {
      m_file.out() << "inlib::wroot::basket::stream :" 
                   << " m_last is not null."
                   << std::endl;
      return false;
    }
    if(!m_entry_offset) {
      m_file.out() << "inlib::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,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()) {
      //NOTE : how / when handle the displacements ?
      m_file.out() << "inlib::wroot::basket::stream :" 
                   << " WARNING : m_data buffer has offsets to displace."
                   << std::endl;
      //if(!const_cast<basket&>(*this).m_data.displace_mapped(m_key_length))
      //  return false; //???
    }

    buffer bref(m_file.out(),m_file.byte_swap(),256);
    if(!_stream_header(bref)) 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;
  }

bool inlib::wroot::basket::update ( uint32 a_offset ) [inline]

Definition at line 153 of file basket.

                               {
    if(m_entry_offset) {
      if((m_nev+1)>=m_nev_buf_size) { //why +1 ?
        uint32 newsize = mx<uint32>(10,2*m_nev_buf_size);
        if(!realloc<uint32>(m_entry_offset,newsize,m_nev_buf_size,true)){
          m_file.out() << "inlib::wroot::basket::update : realloc failed."
                << std::endl;
          return false;
        }
        if(m_displacement) {
          if(!realloc<int>(m_displacement,newsize,m_nev_buf_size,true)){
            m_file.out() << "inlib::wroot::basket::update : realloc failed."
                  << std::endl;
            return false;
          }
        }

        m_nev_buf_size = newsize;

        // Update branch only for the first 10 baskets
        //if (fBranch.writeBasket() < 10) 
        //  fBranch.setEntryOffsetLength(newsize);
      }
      m_entry_offset[m_nev] = a_offset;

      //if (skipped!=offset && !m_displacement){
      //  m_displacement = new int[m_nevSize];
      //  for(int i=0;i<m_nev_buf_size;i++)
      //     m_displacement[i] = m_entry_offset[i];
      //}
      //if (m_displacement) {
      //  m_displacement[m_nev] = skipped;
      //  fBufferRef->setDisplacement(skipped);
      //}

    }
    m_nev++;
    return true;
  }

bool inlib::wroot::basket::write_on_file	(	uint16	a_cycle,
		uint32 &	a_nbytes
	)		`[inline]`

Definition at line 193 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_file.out() << "inlib::wroot::basket::write_on_file :" 
                   << " m_seek_key should be 0."
                   << std::endl;
      return false;
    }

    if(m_version>1000) {
    } else {
      if(m_file.END()>START_BIG_FILE()) {
        //GB : enforce m_version>1000 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_file.out() << "inlib::wroot::basket::write_on_file : " 
        //             << " WARNING : pos>START_BIG_FILE."
        //             << std::endl;

        m_version += 1000;
        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_file.out() << "inlib::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<uint32>(m_entry_offset,m_nev+1)) { //GB : why +1 ?
        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;
    m_file.compress_buffer(m_data,kbuf,klen,kdelete);

    if(klen>m_object_size) {
      m_file.out() << "inlib::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(klen)) { //it will do a file.set_END()
      m_file.out() << "inlib::wroot::basket::write_on_file :" 
                   << " initialize() failed." 
                   << std::endl;
      if(kdelete) delete [] kbuf;
      return false;
    }

    //write header of the key :
   {buffer bref(m_file.out(),m_file.byte_swap(),256);
    if(!_stream_header(bref)) return false;
    if(bref.length()!=m_key_length) {
      m_file.out() << "inlib::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(!key::write_file(nbytes)) return false;
  
    m_data.pos() = m_data.buf(); //empty m_data.

    a_nbytes = m_key_length + klen;
    return true;
  }