Line data    Source code

       1             : 
       2             : /* Copyright (c) 2007-2014, Stefan Eilemann <eile@equalizergraphics.com>
       3             :  *               2011-2012, Daniel Nachbaur <danielnachbaur@gmail.com>
       4             :  *
       5             :  * This library is free software; you can redistribute it and/or modify it under
       6             :  * the terms of the GNU Lesser General Public License version 2.1 as published
       7             :  * by the Free Software Foundation.
       8             :  *
       9             :  * This library is distributed in the hope that it will be useful, but WITHOUT
      10             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
      11             :  * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
      12             :  * details.
      13             :  *
      14             :  * You should have received a copy of the GNU Lesser General Public License
      15             :  * along with this library; if not, write to the Free Software Foundation, Inc.,
      16             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      17             :  */
      18             : 
      19             : namespace lunchbox
      20             : {
      21             : template< class T > Buffer< T >::Buffer( Buffer< T >& from )
      22             : {
      23             :     _data = from._data; _size = from._size; _maxSize = from._maxSize;
      24             :     from._data = 0; from._size = 0; from._maxSize = 0;
      25             : }
      26             : 
      27         904 : template< class T > T* Buffer< T >::pack()
      28             : {
      29         904 :     if( _maxSize != _size )
      30             :     {
      31         904 :         _data = static_cast< T* >( realloc( _data, _size * sizeof( T )));
      32         904 :         _maxSize = _size;
      33             :     }
      34         904 :     return _data;
      35             : }
      36             : 
      37             : template< class T >
      38             : Buffer< T >& Buffer< T >::operator = ( const Buffer< T >& from )
      39             : {
      40             :     replace( from );
      41             :     return *this;
      42             : }
      43             : 
      44         304 : template< class T > T* Buffer< T >::resize( const uint64_t newSize )
      45             : {
      46         304 :     _size = newSize;
      47         304 :     if( newSize <= _maxSize )
      48         152 :         return _data;
      49             : 
      50             :     // avoid excessive reallocs
      51         152 :     const uint64_t nElems = newSize + (newSize >> 3);
      52         152 :     const uint64_t nBytes = nElems * sizeof( T );
      53         152 :     _data = static_cast< T* >( realloc( _data, nBytes ));
      54         152 :     _maxSize = nElems;
      55         152 :     return _data;
      56             : }
      57             : 
      58             : template< class T > void Buffer< T >::grow( const uint64_t newSize )
      59             : {
      60             :     if( newSize > _size )
      61             :         resize( newSize );
      62             : }
      63             : 
      64        1132 : template< class T > T* Buffer< T >::reserve( const uint64_t newSize )
      65             : {
      66        1132 :     if( newSize <= _maxSize )
      67         114 :         return _data;
      68             : 
      69        1018 :     _data = static_cast< T* >( realloc( _data, newSize * sizeof( T )));
      70        1018 :     _maxSize = newSize;
      71        1018 :     return _data;
      72             : }
      73             : 
      74             : template< class T > T* Buffer< T >::reset( const uint64_t newSize )
      75             : {
      76             :     reserve( newSize );
      77             :     setSize( newSize );
      78             :     return _data;
      79             : }
      80             : 
      81             : template< class T >
      82             : void Buffer< T >::append( const T* data, const uint64_t size )
      83             : {
      84             :     LBASSERT( data );
      85             :     LBASSERT( size );
      86             : 
      87             :     const uint64_t oldSize = _size;
      88             :     resize( oldSize + size );
      89             :     memcpy( _data + oldSize, data, size * sizeof( T ));
      90             : }
      91             : 
      92             : template< class T > void Buffer< T >::append( const T& element )
      93             : {
      94             :     resize( _size + 1 );
      95             :     _data[ _size - 1 ] = element;
      96             : }
      97             : 
      98             : template< class T >
      99             : void Buffer< T >::replace( const void* data, const uint64_t size )
     100             : {
     101             :     LBASSERT( data );
     102             :     LBASSERT( size );
     103             : 
     104             :     reserve( size );
     105             :     memcpy( _data, data, size * sizeof( T ));
     106             :     _size = size;
     107             : }
     108             : 
     109             : template< class T > void Buffer< T >::swap( Buffer< T >& buffer )
     110             : {
     111             :     T*             tmpData    = buffer._data;
     112             :     const uint64_t tmpSize    = buffer._size;
     113             :     const uint64_t tmpMaxSize = buffer._maxSize;
     114             : 
     115             :     buffer._data = _data;
     116             :     buffer._size = _size;
     117             :     buffer._maxSize = _maxSize;
     118             : 
     119             :     _data     = tmpData;
     120             :     _size     = tmpSize;
     121             :     _maxSize = tmpMaxSize;
     122             : }
     123             : 
     124         978 : template< class T > bool Buffer< T >::setSize( const uint64_t size )
     125             : {
     126         978 :     LBASSERT( size <= _maxSize );
     127         978 :     if( size > _maxSize )
     128           0 :         return false;
     129             : 
     130         978 :     _size = size;
     131         978 :     return true;
     132             : }
     133             : }