Buffer Class Reference

Generic class for buffers. More...

#include "Buffer.h"

Classes
class	const_iterator
	Buffer's const iterator. More...
class	iterator
	Buffer's iterator. More...

Public Types
typedef size_t	size_type
	Typedef for size type. More...

Public Member Functions
	Buffer (size_type len=0, const uint8 &fill=0)
	Creates buffer of given length. More...
template<typename Iter >
	Buffer (Iter first, Iter last)
	Creates buffer with given content. More...
	Buffer (const Buffer &oth)
	Copy constructor. More...
	~Buffer ()
	Destructor; deletes buffer. More...
template<typename T >
iterator< T >	begin ()
template<typename T >
const_iterator< T >	begin () const
template<typename T >
iterator< T >	end ()
template<typename T >
const_iterator< T >	end () const
template<typename T >
T &	Get (size_type index)
	Gets element from buffer. More...
template<typename T >
const T &	Get (size_type index) const
	Gets const element from buffer. More...
uint8 &	operator[] (size_type index)
	Overload of access operator[]. More...
const uint8 &	operator[] (size_type index) const
	Overload of const access operator[]. More...
template<typename T >
void	Append (const T &value)
	Appends a single value to buffer. More...
template<typename Iter >
void	AppendSeq (Iter first, Iter last)
	Appends a sequence of elements to buffer. More...
template<typename T >
void	Assign (const T &value)
	Assigns a single value to buffer. More...
template<typename Iter >
void	AssignSeq (Iter first, Iter last)
	Assigns a sequence of elements to buffer. More...
template<typename T >
void	AssignAt (const_iterator< T > index, const T &value)
	Assigns a single value to buffer at specific point. More...
template<typename Iter >
void	AssignSeqAt (const_iterator< typename std::iterator_traits< Iter >::value_type > index, Iter first, Iter last)
	Assigns a sequence of elements to buffer at specific point. More...
template<typename T >
Buffer &	operator<< (const T &value)
	Appends a value to buffer. More...
template<typename T >
Buffer &	operator= (const T &value)
	Assigns new value to buffer. More...
Buffer &	operator= (const Buffer &value)
	Copy operator. More...
size_type	size () const
size_type	capacity () const
template<typename T >
void	Reserve (size_type requiredCount)
	Reserves (pre-allocates) memory for buffer. More...
template<typename T >
void	ReserveAt (const_iterator< T > index, size_type requiredCount)
	Reserves (pre-allocates) memory for buffer at specific point. More...
template<typename T >
void	Resize (size_type requiredCount, const uint8 &fill=0)
	Resizes buffer. More...
template<typename T >
void	ResizeAt (const_iterator< T > index, size_type requiredCount, const uint8 &fill=0)
	Resizes buffer. More...

Protected Member Functions
template<typename T >
void	_Resize (size_type requiredCount)
	Resizes buffer. More...
template<typename T >
void	_ResizeAt (const_iterator< T > index, size_type requiredCount)
	Resizes buffer. More...
void	_Reallocate (size_type requiredSize)
	Reallocates buffer. More...

Static Protected Member Functions
static size_type	_CalcBufferCapacity (size_type currentCapacity, size_type requiredSize)
	Calculates buffer capacity. More...

Protected Attributes
uint8 *	mBuffer
	Pointer to start of buffer. More...
size_type	mSize
	Current size of buffer, in bytes. More...
size_type	mCapacity
	Current capacity of buffer, in bytes. More...

Detailed Description

Generic class for buffers.

This class incorporates all stuff which may be handy when manipulating with buffers.

Author

Bloody.Rabbit

Definition at line 40 of file Buffer.h.

Member Typedef Documentation

typedef size_t Buffer::size_type

Typedef for size type.

Definition at line 44 of file Buffer.h.

Constructor & Destructor Documentation

Buffer::Buffer ( size_type  len = 0, const uint8 &  fill = 0  )

inline

Creates buffer of given length.

Resizes buffer to be len bytes long, filling it with value.

Parameters

[in]	len	Length of buffer to be created.
[in]	fill	Value to fill the buffer with.

Definition at line 332 of file Buffer.h.

    : mBuffer( NULL ),
      mSize( 0 ),
      mCapacity( 0 )
    {
        /* unfortunately, we cannot use template here
           since it's not possible to explicitly instantiate
           constructor .... assuming uint8 */
        Resize< uint8 >( len, fill );
    }

template<typename Iter >

Buffer::Buffer ( Iter  first, Iter  last  )

inline

Creates buffer with given content.

Fills buffer with content determined by iterators first and last.

Parameters

[in]	first	Iterator pointing to first element.
[in]	last	Iterator pointing to element after the last one.

Definition at line 352 of file Buffer.h.

References AssignSeq().

    : mBuffer( NULL ),
      mSize( 0 ),
      mCapacity( 0 )
    {
        // assign the content
        AssignSeq( first, last );
    }

Here is the call graph for this function:

Buffer::Buffer ( const Buffer &  oth )

inline

Copy constructor.

Definition at line 361 of file Buffer.h.

    : mBuffer( NULL ),
      mSize( 0 ),
      mCapacity( 0 )
    {
        // Use assignment operator
        *this = oth;
    }

Buffer::~Buffer ( )

inline

Destructor; deletes buffer.

Definition at line 370 of file Buffer.h.

References mBuffer, and SafeFree().

    {
        // Free buffer
        SafeFree( mBuffer );
    }

Here is the call graph for this function:

Member Function Documentation

static size_type Buffer::_CalcBufferCapacity ( size_type  currentCapacity, size_type  requiredSize  )

inlinestaticprotected

Calculates buffer capacity.

Based on current capacity and required size of the buffer, this function calculates capacity of buffer to be allocated.

Parameters

[in]	currentCapacity	Current capacity of buffer, in bytes.
[in]	requiredSize	Required size of buffer, in bytes.

Returns

Capacity to be allocated.

Definition at line 791 of file Buffer.h.

References npowof2().

Referenced by _Reallocate().

    {
        size_type newCapacity = 0;

        // if more than 0x100 bytes required, return next power of 2
        if( 0x100 < requiredSize )
            newCapacity = (size_type)npowof2( requiredSize );
        // else if non-zero, return 0x100 bytes
        else if( 0 < requiredSize )
            newCapacity = 0x100;
        // else return 0 bytes

        /* if current capacity is sufficient and at the same time smaller
           than the new capacity, return current one ... saves resources */
        if( requiredSize <= currentCapacity && currentCapacity < newCapacity )
            return currentCapacity;
        else
            return newCapacity;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void Buffer::_Reallocate ( size_type  requiredSize )

inlineprotected

Reallocates buffer.

Reallocates buffer so it can efficiently store given amount of data.

Parameters

[in]

requiredSize

The least required new size of buffer, in bytes.

Definition at line 763 of file Buffer.h.

References _CalcBufferCapacity(), and capacity().

Referenced by _ResizeAt(), and ReserveAt().

    {
        // calculate new capacity for required size
        size_type newCapacity = _CalcBufferCapacity( capacity(), requiredSize );
        // make sure new capacity is bigger than required size
        assert( requiredSize <= newCapacity );

        // has the capacity changed?
        if( newCapacity != capacity() )
        {
            // reallocate
            mBuffer = (uint8*)realloc( mBuffer, newCapacity );
            // set new capacity
            mCapacity = newCapacity;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

void Buffer::_Resize ( size_type  requiredCount )

inlineprotected

Resizes buffer.

Similar to Resize, but does not care about the gaps that may be created.

Parameters

[in]

requiredCount

The number of elements to hold.

Definition at line 725 of file Buffer.h.

    {
        // resize at beginning
        _ResizeAt< T >( begin< T >(), requiredCount );
    }

template<typename T >

void Buffer::_ResizeAt ( const_iterator< T >  index, size_type  requiredCount  )

inlineprotected

Resizes buffer.

Similar to ResizeAt, but does not care about the gaps that may be created.

Parameters

[in]	index	The point at which the buffer should be resized.
[in]	requiredCount	The number of elements to hold.

Definition at line 740 of file Buffer.h.

References _Reallocate().

    {
        // make sure we're not going off the bounds
        assert( index <= end< T >() );

        // turn index into byte offset
        const size_type _index = ( index.template As< uint8 >() - begin< uint8 >() );
        // obtain required size in bytes
        const size_type _requiredSize = sizeof( T ) * requiredCount;

        // reallocate
        _Reallocate( _index + _requiredSize );
        // set new size
        mSize = ( _index + _requiredSize );
    }

Here is the call graph for this function:

template<typename T >

void Buffer::Append ( const T &  value )

inline

Appends a single value to buffer.

Parameters

[in]

value

Value to be appended.

Definition at line 437 of file Buffer.h.

Referenced by SystemBubble::AddBallExclusive(), SystemManager::AddMarker(), Sentry::EncodeDestiny(), CustomsSE::EncodeDestiny(), Concord::EncodeDestiny(), Missile::EncodeDestiny(), NPC::EncodeDestiny(), DroneSE::EncodeDestiny(), AsteroidSE::EncodeDestiny(), StructureSE::EncodeDestiny(), AnomalySE::EncodeDestiny(), ContainerSE::EncodeDestiny(), WormholeSE::EncodeDestiny(), StationSE::EncodeDestiny(), SystemEntity::EncodeDestiny(), WreckSE::EncodeDestiny(), StaticSystemEntity::EncodeDestiny(), ShipSE::EncodeDestiny(), ItemSystemEntity::EncodeDestiny(), FieldSE::EncodeDestiny(), ObjectSystemEntity::EncodeDestiny(), DynamicSystemEntity::EncodeDestiny(), SystemManager::MakeSetState(), MarshalStream::Put(), PyDecodeEscape(), SystemBubble::SendAddBalls(), SystemBubble::SendAddBalls2(), SystemManager::SendStaticBall(), and MarshalStream::VisitPackedRow().

    {
        // we wish to append to the end
        const const_iterator< T > index = end< T >();

        // make enough room; we're going to fill the gap immediately
        _ResizeAt< T >( index, 1 );

        // assign the value, filling the gap
        AssignAt< T >( index, value );
    }

Here is the caller graph for this function:

template<typename Iter >

void Buffer::AppendSeq ( Iter  first, Iter  last  )

inline

Appends a sequence of elements to buffer.

Parameters

[in]	first	Iterator pointing to first element.
[in]	last	Iterator pointing to element after the last one.

Definition at line 455 of file Buffer.h.

Referenced by StreamPacketizer::InputData(), MarshalDeflate(), MarshalStream::Put(), and MarshalStream::VisitPackedRow().

    {
        // we wish to append to the end
        const const_iterator< typename std::iterator_traits< Iter >::value_type >
        index = end< typename std::iterator_traits< Iter >::value_type >();

        // make enough room; we're going to fill the gap immediately
        _ResizeAt< typename std::iterator_traits< Iter >::value_type >( index, last - first );

        // assign the value, filling the gap
        AssignSeqAt< Iter >( index, first, last );
    }

Here is the caller graph for this function:

template<typename T >

void Buffer::Assign ( const T &  value )

inline

Assigns a single value to buffer.

Parameters

[in]

value

New content.

Definition at line 474 of file Buffer.h.

    {
        // we wish to assign to beginning
        const const_iterator< T > index = begin< T >();

        // do we have enough space?
        if( 1 <= end< T >() - index )
        {
            // yes, we do: assign the value
            AssignAt< T >( index, value );

            // shrink the buffer; no gap will be created
            _ResizeAt< T >( index, 1 );
        }
        else
        {
            // no, we don't: make enough room; we're going to fill the gap immediately
            _ResizeAt< T >( index, 1 );

            // assign the value, filling the gap
            AssignAt< T >( index, value );
        }
    }

template<typename T >

void Buffer::AssignAt ( const_iterator< T >  index, const T &  value  )

inline

Assigns a single value to buffer at specific point.

Parameters

[in]	index	Point at which the value should be assigned.
[in]	value	New content.

Definition at line 536 of file Buffer.h.

References mBuffer.

    {
        // make sure we're not going off the bounds
        assert( 1 <= end< T >() - index );

        // turn iterator into byte offset
        const size_type _index = ( index.template As< uint8 >() - begin< uint8 >() );
        // assign the value
        *(T*)&mBuffer[ _index ] = value;
    }

template<typename Iter >

void Buffer::AssignSeq ( Iter  first, Iter  last  )

inline

Assigns a sequence of elements to buffer.

Parameters

[in]	first	Iterator pointing to first element.
[in]	last	Iterator pointing to element after the last one.

Definition at line 504 of file Buffer.h.

References end().

Referenced by Buffer(), operator=(), StreamPacketizer::Process(), and TCPConnection::SendData().

    {
        // we wish to assign to beginning
        const const_iterator< typename std::iterator_traits< Iter >::value_type >
            index = begin< typename std::iterator_traits< Iter >::value_type >();

        // do we have enough space?
        if( last - first <= end< typename std::iterator_traits< Iter >::value_type >() - index )
        {
            // yes, we do: assign the value
            AssignSeqAt< Iter >( index, first, last );

            // shrink the buffer; no gap will be created
            _ResizeAt< typename std::iterator_traits< Iter >::value_type >( index, last - first );
        }
        else
        {
            // no, we don't: make enough room; we're going to fill the gap immediately
            _ResizeAt< typename std::iterator_traits< Iter >::value_type >( index, last - first );

            // assign the value, filling the gap
            AssignSeqAt< Iter >( index, first, last );
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Iter >

void Buffer::AssignSeqAt ( const_iterator< typename std::iterator_traits< Iter >::value_type >  index, Iter  first, Iter  last  )

inline

Assigns a sequence of elements to buffer at specific point.

Parameters

[in]	index	Point at which the sequence of elements should be assigned.
[in]	first	Iterator pointing to first element.
[in]	last	Iterator pointing to element after the last one.

Definition at line 554 of file Buffer.h.

References end(), and mBuffer.

    {
        // make sure we're not going off the bounds
        assert( last - first <= end< typename std::iterator_traits< Iter >::value_type >() - index );

        // is there anything to assign?
        if( first != last )
        {
            // turn the iterator into byte offset
            const size_type _index = ( index.template As< uint8 >() - begin< uint8 >() );
            // obtain byte length of input data
            const size_type _len = sizeof( typename std::iterator_traits< Iter >::value_type ) * ( last - first );
            // assign the content
            memmove( &mBuffer[ _index ], &*first, _len );
        }
    }

Here is the call graph for this function:

template<typename T >

iterator< T > Buffer::begin ( )

inline

Returns

iterator to begin.

Definition at line 381 of file Buffer.h.

Referenced by EVETCPConnection::DumpBuffer(), StreamPacketizer::InputData(), UnmarshalStream::Load(), UnmarshalStream::LoadPackedRow(), MarshalDeflate(), operator=(), StreamPacketizer::Process(), TCPConnection::SendData(), MailDB::SendMail(), MarshalStream::VisitPackedRow(), and MarshalStream::VisitSubStream().

{ return iterator< T >( this, 0 ); }

Here is the caller graph for this function:

template<typename T >

const_iterator< T > Buffer::begin ( ) const

inline

Returns

const_iterator to begin.

Definition at line 384 of file Buffer.h.

{ return const_iterator< T >( this, 0 ); }

size_type Buffer::capacity ( ) const

inline

Returns

Current capacity of buffer, in bytes.

Definition at line 612 of file Buffer.h.

References mCapacity.

Referenced by _Reallocate(), and ReserveAt().

{ return mCapacity; }

Here is the caller graph for this function:

template<typename T >

iterator< T > Buffer::end ( )

inline

Returns

iterator to end.

Definition at line 387 of file Buffer.h.

References size().

Referenced by AssignSeq(), AssignSeqAt(), DeflateData(), EVETCPConnection::DumpBuffer(), InflateData(), StreamPacketizer::InputData(), MarshalDeflate(), Buffer::const_iterator< uint8 >::operator*(), operator=(), StreamPacketizer::Process(), EVETCPConnection::QueueRep(), TCPConnection::SendData(), MailDB::SendMail(), MarshalStream::VisitPackedRow(), and MarshalStream::VisitSubStream().

{ return iterator< T >( this, size() ); }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

const_iterator< T > Buffer::end ( ) const

inline

Returns

const_iterator to end.

Definition at line 390 of file Buffer.h.

References size().

{ return const_iterator< T >( this, size() ); }

Here is the call graph for this function:

template<typename T >

T& Buffer::Get ( size_type  index )

inline

Gets element from buffer.

Parameters

[in]

index

Index of element in the buffer.

Returns

Reference to element.

Definition at line 400 of file Buffer.h.

{ return *( begin< T >() + index ); }

template<typename T >

const T& Buffer::Get ( size_type  index ) const

inline

Gets const element from buffer.

Parameters

[in]

index

Index of element in the buffer.

Returns

Const reference to element.

Definition at line 409 of file Buffer.h.

{ return *( begin< T >() + index ); }

template<typename T >

Buffer& Buffer::operator<< ( const T &  value )

inline

Appends a value to buffer.

Parameters

[in]

value

Value to be appended.

Definition at line 577 of file Buffer.h.

    {
        // append the value
        Append< T >( value );
        // return ourselves
        return *this;
    }

template<typename T >

Buffer& Buffer::operator= ( const T &  value )

inline

Assigns new value to buffer.

Parameters

[in]

value

New content.

Definition at line 590 of file Buffer.h.

    {
        // assign the value
        Assign< T >( value );
        // return ourselves
        return *this;
    }

Buffer& Buffer::operator= ( const Buffer &  value )

inline

Copy operator.

Definition at line 598 of file Buffer.h.

References AssignSeq(), begin(), and end().

    {
        // assign new content
        AssignSeq( value.begin< uint8 >(), value.end< uint8 >() );
        // return ourselves
        return *this;
    }

Here is the call graph for this function:

uint8& Buffer::operator[] ( size_type  index )

inline

Overload of access operator[].

Parameters

[in]

index

Index of byte to be returned.

Returns

Reference to required byte.

Definition at line 418 of file Buffer.h.

{ return Get< uint8 >( index ); }

const uint8& Buffer::operator[] ( size_type  index ) const

inline

Overload of const access operator[].

Parameters

[in]

index

Index of byte to be returned.

Returns

Const reference to required byte.

Definition at line 426 of file Buffer.h.

{ return Get< uint8 >( index ); }

template<typename T >

void Buffer::Reserve ( size_type  requiredCount )

inline

Reserves (pre-allocates) memory for buffer.

Pre-allocates memory for buffer to hold at least requiredCount number of elements.

Should be used in cases where lazy reallocating can negatively affect performance.

Parameters

[in]

requiredCount

The least reserved number of elements.

Definition at line 626 of file Buffer.h.

Referenced by MarshalStream::VisitPackedRow().

    {
        // reserve at beginning
        ReserveAt< T >( begin< T >(), requiredCount );
    }

Here is the caller graph for this function:

template<typename T >

void Buffer::ReserveAt ( const_iterator< T >  index, size_type  requiredCount  )

inline

Reserves (pre-allocates) memory for buffer at specific point.

Pre-allocates memory for buffer to hold at least requiredCount number of elements, counting from index.

Should be used in cases where lazy reallocating can negatively affect performance.

Parameters

[in]	index	The point at which the memory should be reserved.
[in]	requiredCount	The least reserved number of elements.

Definition at line 645 of file Buffer.h.

References _Reallocate(), and capacity().

    {
        // make sure we're not going off the bounds
        assert( index <= end< T >() );

        // turn iterator into byte offset
        const size_type _index = ( index.template As< uint8 >() - begin< uint8 >() );
        // obtain required size in bytes
        const size_type _requiredSize = sizeof( T ) * requiredCount;

        // reallocate if necessary
        if( _index + _requiredSize > capacity() )
            _Reallocate( _index + _requiredSize );
    }

Here is the call graph for this function:

template<typename T >

void Buffer::Resize ( size_type  requiredCount, const uint8 &  fill = 0  )

inline

Resizes buffer.

Changes size of buffer to hold requiredCount number of elements, possibly reallocating it.

Parameters

[in]	requiredCount	The number of elements to hold.
[in]	fill	During buffer expansion the gap will be filled by this value.

Definition at line 670 of file Buffer.h.

Referenced by TCPConnection::RecvData().

    {
        // Resize at beginning
        ResizeAt< T >( begin< T >(), requiredCount, fill );
    }

Here is the caller graph for this function:

template<typename T >

void Buffer::ResizeAt ( const_iterator< T >  index, size_type  requiredCount, const uint8 &  fill = 0  )

inline

Resizes buffer.

Changes size of buffer to hold requiredCount number of elements, counting from index, possibly reallocating it.

Parameters

[in]	index	The point at which the buffer should be resized.
[in]	requiredCount	The number of elements to hold.
[in]	fill	During buffer expansion the gap will be filled by this value.

Definition at line 688 of file Buffer.h.

References mBuffer, and size().

Referenced by DeflateData(), InflateData(), and EVETCPConnection::QueueRep().

    {
        // make sure we're not going off the bounds
        assert( index <= end< T >() );

        // keep old size
        const size_type _oldSize = size();
        // do actual resize
        _ResizeAt< T >( index, requiredCount );

        // turn iterator into byte offset
        const size_type _index = ( index.template As< uint8 >() - begin< uint8 >() );
        // obtain required size in bytes
        const size_type _requiredSize = sizeof( T ) * requiredCount;

        // has a gap been created?
        if( _index + _requiredSize > _oldSize )
            // fill it with value
            memset( &mBuffer[ _oldSize ], fill, _index + _requiredSize - _oldSize );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

size_type Buffer::size ( ) const

inline

Returns

Current size of buffer, in bytes.

Definition at line 610 of file Buffer.h.

References mSize.

Referenced by PyService::_BuildCachedReturn(), CachedObjectMgr::_UpdateCache(), DeflateData(), DestinyDumpLogText(), end(), CachedObjectMgr::GetCacheFileName(), PyBuffer::hash(), InflateData(), UnmarshalStream::Load(), UnmarshalStream::LoadRLE(), MarshalDeflate(), Buffer::const_iterator< uint8 >::operator+=(), EVETCPConnection::PopRep(), EVETCPConnection::QueueRep(), TCPConnection::RecvData(), ResizeAt(), MarshalStream::SaveRLE(), TCPConnection::SendData(), PyBuffer::size(), PyDumpVisitor::VisitBuffer(), and MarshalStream::VisitSubStream().

{ return mSize; }

Here is the caller graph for this function:

Member Data Documentation

uint8* Buffer::mBuffer

protected

Pointer to start of buffer.

Definition at line 711 of file Buffer.h.

Referenced by AssignAt(), AssignSeqAt(), Buffer::const_iterator< uint8 >::operator*(), ResizeAt(), and ~Buffer().

size_type Buffer::mCapacity

protected

Current capacity of buffer, in bytes.

Definition at line 715 of file Buffer.h.

Referenced by capacity().

size_type Buffer::mSize

protected

Current size of buffer, in bytes.

Definition at line 713 of file Buffer.h.

Referenced by size().

---

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

• /backups/local/src/eve/EvEmu_Crucible/src/eve-core/utils/Buffer.h