TPIntegerVector_p2.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include <cstring>
#include <stdexcept>
 
 
inline
bool TPIntegerVector_p2::lastElement() const {
   return  m_storage->size() == (m_position>>1) + 1;
}
 
inline
unsigned TPIntegerVector_p2::startPos() const {      
   return  m_position?  m_storage->m_endPos[m_position-1] : 0;
}
 
inline
unsigned TPIntegerVector_p2::size() const {      
     return m_storage->m_endPos[m_position] - startPos();
}
 
inline
unsigned TPIntegerVector_p2::reserved() const {      
     return m_storage->m_endPos[m_position+1] - startPos();
}
 
inline
void TPIntegerVector_p2::resize( size_t  new_size ) {
   if( new_size > reserved() && !lastElement() )
      throw std::runtime_error("TPIntegerVector_p2::resize() can only enlarge the last element beyond its reserved size");
   size_t end = startPos() + new_size;
   m_storage->m_endPos[m_position] = end;
   if( lastElement() ) {
      if( m_storage->m_endPos[m_position+1] < end )
        m_storage->m_endPos[m_position+1] = end;
     m_storage->m_data.resize( end );
   }
}
 
inline
void TPIntegerVector_p2::grow( const size_t diff ) {
   resize( size() + diff );
}
   
inline
void TPIntegerVector_p2::reserve( size_t  new_size ) {
   if( new_size > reserved() && !lastElement() )
      throw std::runtime_error("TPIntegerVector_p2::reserve() can only enlarge the last element!");
   if( size() >= new_size || !lastElement() )
      return;
   size_t end = startPos() + new_size;
   m_storage->m_endPos[m_position+1] = end;
   m_storage->m_data.reserve( end );
}
 
 
 
inline
TPIntegerVector_p2::value_type&
TPIntegerVector_p2::operator[]( size_t idx ) {
   return const_cast<value_type&>(((const TPIntegerVector_p2*)this)->operator[](idx));
}
 
inline
const TPIntegerVector_p2::value_type&
TPIntegerVector_p2::operator[]( size_t idx ) const {
   return m_storage->m_data[ startPos() + idx ];
}
 
 
 
inline
void    TPIntegerVector_p2::push_back( const value_type& val )
{
   resize( size() + 1 );
   m_storage->m_data[ m_storage->m_endPos[m_position] - 1 ] = val; 
}
  
 
inline
void    TPIntegerVector_p2::push_int( const int& val )
{
   push_back( (value_type)val );
}
  
 
inline
void    TPIntegerVector_p2::push_float( const float& val )
{
   union {unsigned int i; float f;} m_union;
   m_union.f = val;
   push_back( m_union.i );
}
 
 
inline
void    TPIntegerVector_p2::push_double( const double& val )
{
   union {struct{unsigned int i1;unsigned int i2;} c; double d;} m_union;
   m_union.d = val;
   push_back( m_union.c.i1 );
   push_back( m_union.c.i2 );
}
 
inline  void
TPIntegerVector_p2::push_chars( const char * const s )
{
   _store_bytes( (void*)s, strlen(s)+1 );
}
   
 
inline  void
TPIntegerVector_p2::push_string( const std::string& str )
{
   push_chars( str.c_str() );
}
   
 
inline  void
TPIntegerVector_p2::push_bytes( const void * bytes, size_t bytelen )
{
   push_back( bytelen );
   _store_bytes( bytes, bytelen);
}
 
 
inline  void
TPIntegerVector_p2::_store_bytes( const void *  buff, size_t bytelen )
{
   size_t intlen( size_for_blob(bytelen) - 1 );
   grow( intlen );
   // need to grow first and take address later, because of possible memory reallocation
   value_type& start = m_storage->m_data[ m_storage->m_endPos[m_position] - intlen ];
   memcpy( (void*)&start, buff, bytelen );
}
 
 
 
inline
void    TPIntegerVector_p2::push_TPObjRef( const TPObjRef& val )
{
   union {struct{unsigned short i1;unsigned short i2;} c; unsigned int I;} m_union;
   m_union.c.i1 = val.topLevelCnvID();
   m_union.c.i2 = val.typeID() & 0xFFFF;
   push_back( m_union.I );
   push_back( val.index());
}
 
inline
void    TPIntegerVector_p2::push_vTPObjRef( const std::vector<TPObjRef>& val )
{
   size_t size = val.size();
   push_back( size );
   for( size_t i=0; i<size; i++ )
      push_TPObjRef( val[i] );
}
 
 
template<typename T>
inline  size_t
TPIntegerVector_p2::size_for( const T& obj )
{
   return ( sizeof(obj) + sizeof(value_type)-1 ) / sizeof(value_type);
}
 
 
inline  size_t
TPIntegerVector_p2::size_for( const char *s )
{
   return strlen(s) / sizeof(value_type) + 1;
}
 
inline  size_t
TPIntegerVector_p2::size_for_ref( )
{
   return ( sizeof(TPObjRef) + sizeof(value_type)-1 ) / sizeof(value_type);
}
 
 
 
template<>
inline  size_t
TPIntegerVector_p2::size_for( const std::string& str )
{
   return str.length() / sizeof(value_type) + 1;
}
 
inline  size_t
TPIntegerVector_p2::size_for_blob( size_t blobsize )
{
   return ( blobsize + sizeof(value_type)-1 ) / sizeof(value_type) + 1;
}
 
 
inline  size_t
TPIntegerVector_p2::next_string_size( const TPIntegerVector_p2::const_iterator& iter ) const
{
   return strlen( (const char *)&*iter );
}
 
inline  size_t
TPIntegerVector_p2::next_blob_size( const TPIntegerVector_p2::const_iterator& iter ) const
{
   return (size_t)*iter;
}
 
 
    
inline
const TPIntegerVector_p2::value_type&
TPIntegerVector_p2::next( TPIntegerVector_p2::const_iterator& iter )  const
{
   return *iter++;
}
 
    
inline int
TPIntegerVector_p2::next_int( TPIntegerVector_p2::const_iterator& iter ) const
{
   return (int)*iter++;
}
 
    
inline float
TPIntegerVector_p2::next_float( TPIntegerVector_p2::const_iterator& iter ) const
{
   union {unsigned int i; float f;} m_union;
   m_union.i = *iter++;
   return m_union.f;
}
    
inline double
TPIntegerVector_p2::next_double( TPIntegerVector_p2::const_iterator& iter ) const
{
   union {struct{unsigned int i1;unsigned int i2;} c; double d;} m_union;
   m_union.c.i1 = *iter++;
   m_union.c.i2 = *iter++;
   return m_union.d;
}
    
inline TPObjRef
TPIntegerVector_p2::next_TPObjRef( TPIntegerVector_p2::const_iterator& iter ) const
{
   union {struct{unsigned short i1;unsigned short i2;} c; unsigned int I;} m_union;
   m_union.I = *iter++;
   return TPObjRef(TPObjRef::typeID_t(m_union.c.i1, m_union.c.i2), (int)*iter++ );
}
 
 
inline void
TPIntegerVector_p2::next_chars( TPIntegerVector_p2::const_iterator& iter, char *buff, size_t bufflen  ) const
{
   const char *s = (const char *)&*iter;
   size_t slen = strlen(s);
   iter += slen/sizeof(value_type) + 1;
   assert( bufflen > slen );
   if( bufflen <= slen)  slen = bufflen-1;
   memcpy( (void*)buff, (void*)s, slen+1 );
}
 
inline  std::string
TPIntegerVector_p2::next_string( const_iterator& iter ) const
{
   const char *s = (const char *)&*iter;
   iter +=  strlen(s) / sizeof(value_type) + 1;
   return std::string( s );
}
 
 
inline void
TPIntegerVector_p2::next_bytes( TPIntegerVector_p2::const_iterator& iter, void *buff, size_t bufflen  ) const
{
   value_type size = *iter++;
   const void *b = &*iter;
   iter += size/sizeof(value_type);
   assert( bufflen >= size );
   if( bufflen < size)  size = bufflen;
   memcpy( buff, b, size );
}
   
 
inline
void TPIntegerVector_p2::next_vTPObjRef( TPIntegerVector_p2::const_iterator& iter, std::vector<TPObjRef>& refs ) const
{
   value_type size = *iter++;
   refs.clear();
   refs.reserve( size );
   for( value_type i=0; i<size; i++ )
      refs.push_back( next_TPObjRef(iter) );
}