Inheritance diagram for inlib::rroot::basket:

Collaboration diagram for inlib::rroot::basket:

Public Member Functions
virtual void *	cast (const std::string &a_class) const
virtual bool	stream (buffer &a_buffer)
	basket (ifile &a_file)
	basket (ifile &a_file, 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
bool	read_offset_tables ()
Static Public Member Functions
static const std::string &	s_class ()
Protected Member Functions
void	_clear ()
Protected Attributes
uint32	m_nev_buf_size
uint32	m_nev
uint32	m_last
int *	m_entry_offset
int *	m_displacement

Detailed Description

Definition at line 16 of file basket.

Constructor & Destructor Documentation

inlib::rroot::basket::basket ( ifile & a_file ) [inline]

Definition at line 171 of file basket.

  :key(a_file)
  ,m_nev_buf_size(0)
  ,m_nev(0)
  ,m_last(0)
  ,m_entry_offset(0)
  ,m_displacement(0)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }

inlib::rroot::basket::basket	(	ifile &	a_file,
		seek	a_pos,
		uint32	a_nbytes
	)		`[inline]`

Definition at line 183 of file basket.

  :key(a_file,a_pos,a_nbytes)
  ,m_entry_offset(0)
  ,m_displacement(0)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }

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

Definition at line 192 of file basket.

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

inlib::rroot::basket::basket ( const basket & a_from ) [inline]

Definition at line 199 of file basket.

  : iro(a_from)
  ,key(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 INLIB_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_file.out() << "inlib::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_file.out() << "inlib::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

void inlib::rroot::basket::_clear ( ) [inline, protected]

Definition at line 329 of file basket.

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

virtual void* inlib::rroot::basket::cast ( const std::string & a_class ) const [inline, virtual]

Implements inlib::rroot::iro.

Definition at line 24 of file basket.

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

int* inlib::rroot::basket::displacement ( ) [inline]

Definition at line 272 of file basket.

{return m_displacement;}

int* inlib::rroot::basket::entry_offset ( ) [inline]

Definition at line 271 of file basket.

{return m_entry_offset;}

uint32 inlib::rroot::basket::nev ( ) const [inline]

Definition at line 274 of file basket.

{return m_nev;}

uint32 inlib::rroot::basket::nev_buf_size ( ) const [inline]

Definition at line 273 of file basket.

{return m_nev_buf_size;}

basket& inlib::rroot::basket::operator= ( const basket & a_from ) [inline]

Definition at line 234 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;

    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_file.out() << "inlib::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_file.out() << "inlib::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;
  }

bool inlib::rroot::basket::read_offset_tables ( ) [inline]

Definition at line 276 of file basket.

                            {
    if(!m_buffer) return false;    
    if(!m_last) return false;    

    delete [] m_entry_offset;
    m_entry_offset = 0;

    rroot::buffer buffer(m_file.out(),m_file.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_file.out() << "inlib::rroot::basket::read_offset_tables :"
                   << " read_array failed."
                   << std::endl;
      return false;
    }
    if((n!=m_nev)&&(n!=(m_nev+1))) {
      m_file.out() << "inlib::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_file.out() << "inlib::rroot::basket::read_offset_tables :"
                     << " readArray(2) failed."
                     << std::endl;
        return false;
      }
      if((n!=m_nev)&&(n!=(m_nev+1))) {
        m_file.out() << "inlib::rroot::basket::read_offset_tables :"
                     << " m_displacement read len mismatch."
                     << " n " << n
                     << " m_nev " << m_nev
                     << std::endl;
        return false;
      }
    }

    return true;
  }

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

Reimplemented from inlib::rroot::key.

Definition at line 19 of file basket.

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

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

Implements inlib::rroot::iro.

Definition at line 28 of file basket.

                                        {
    _clear();

    uint32 startpos = a_buffer.length();

    if(!key::from_buffer(a_buffer.eob(),a_buffer.pos())) 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_file.out() << "inlib::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_file.out() << "inlib::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_file.out() << "inlib::rroot::basket::stream :"
                   << " bad flag " << (int)flag
                   << std::endl; 
      return false;
    }

    if((flag%10)!=2) {
      if(!m_nev_buf_size) {
        m_file.out() << "inlib::rroot::basket::stream :" 
                     << " m_nev_buf_size is zero." << std::endl; 
        return false;
      }
      if(m_nev>m_nev_buf_size) {
        m_file.out() << "inlib::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_file.out() << "inlib::rroot::basket::stream :" 
                       << " m_entry_offset read len mismatch."
                       << " n " << n
                       << " m_nev " << m_nev
                       << std::endl;
          _clear();
          return false;
        }
      }
      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_file.out() << "inlib::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_file.out() << "inlib::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;
  }