Buffer.h

Go to the documentation of this file.

/*
    ------------------------------------------------------------------------------------
    LICENSE:
    ------------------------------------------------------------------------------------
    This file is part of EVEmu: EVE Online Server Emulator
    Copyright 2006 - 2021 The EVEmu Team
    For the latest information visit https://evemu.dev
    ------------------------------------------------------------------------------------
    This program is free software; you can redistribute it and/or modify it under
    the terms of the GNU Lesser General Public License as published by the Free Software
    Foundation; either version 2 of the License, or (at your option) any later
    version.

    This program is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License along with
    this program; if not, write to the Free Software Foundation, Inc., 59 Temple
    Place - Suite 330, Boston, MA 02111-1307, USA, or go to
    http://www.gnu.org/copyleft/lesser.txt.
    ------------------------------------------------------------------------------------
    Author:     Bloody.Rabbit
*/

#ifndef __UTILS__BUFFER_H__INCL__
#define __UTILS__BUFFER_H__INCL__

#include "utils/misc.h"
#include "memory/SafeMem.h"

class Buffer
{
public:
    typedef size_t size_type;

    template< typename T >
    class const_iterator
    : public std::iterator< std::random_access_iterator_tag, T >
    {
        typedef std::iterator< std::random_access_iterator_tag, T > _Base;

    public:
        typedef typename _Base::iterator_category iterator_category;
        typedef typename _Base::value_type        value_type;
        typedef typename _Base::difference_type   difference_type;
        typedef typename _Base::pointer           pointer;
        typedef typename _Base::reference         reference;

        typedef const T* const_pointer;
        typedef const T& const_reference;

        const_iterator( const Buffer* buffer = NULL, size_type index = 0 )
        : mIndex( index ),
          mBuffer( buffer )
        {
        }
        const_iterator( const const_iterator& oth )
        : mIndex( oth.mIndex ),
          mBuffer( oth.mBuffer )
        {
        }

        const_iterator& operator=( const const_iterator& oth )
        {
            mIndex = oth.mIndex;
            mBuffer = oth.mBuffer;
            return *this;
        }

        template< typename T2 >
        const_iterator< T2 > As() const { return const_iterator< T2 >( mBuffer, mIndex ); }

        const_reference operator*() const
        {
            // make sure we have valid buffer
            assert( mBuffer );
            // make sure we're not going off the bounds
            assert( 1 <= mBuffer->end< value_type >() - *this );

            // obtain the value and return
            return *(const_pointer)&( mBuffer->mBuffer )[ mIndex ];
        }
        const_pointer operator->() const { return &**this; }
        const_reference operator[]( difference_type diff ) const { return *( *this + diff ); }

        const_iterator operator+( difference_type diff ) const
        {
            const_iterator res( *this );
            return ( res += diff );
        }
        const_iterator& operator+=( difference_type diff )
        {
            // turn the diff into byte diff
            const difference_type res = ( diff * sizeof( value_type ) );

            // make sure we have valid buffer
            assert( mBuffer );
            // make sure we won't go negative
            assert( 0 <= mIndex + res );
            // make sure we won't go past end
            assert( mIndex + res <= mBuffer->size() );

            // set new index
            mIndex += res;

            return *this;
        }
        const_iterator& operator++() { return ( *this += 1 );  }
        const_iterator operator++( int )
        {
            const_iterator res( *this );
            ++*this;
            return res;
        }

        const_iterator operator-( difference_type diff ) const
        {
            const_iterator res( *this );
            return ( res -= diff );
        }
        const_iterator& operator-=( difference_type diff ) { return ( *this += ( -diff ) ); }
        const_iterator& operator--() { return ( *this -= 1 ); }
        const_iterator operator--( int )
        {
            const_iterator res( *this );
            --*this;
            return res;
        }

        difference_type operator-( const const_iterator& oth ) const
        {
            // make sure we have same parent buffer
            assert( oth.mBuffer == mBuffer );
            // return difference in element offset
            return ( ( mIndex - oth.mIndex ) / sizeof( value_type ) );
        }

        bool operator==( const const_iterator& oth ) const
        {
            // make sure we have same parent buffer
            assert( oth.mBuffer == mBuffer );
            // return the result
            return ( mIndex == oth.mIndex );
        }
        bool operator!=( const const_iterator& oth ) const { return !( *this == oth ); }

        bool operator<( const const_iterator& oth ) const
        {
            // make sure we have same parent buffer
            assert( oth.mBuffer == mBuffer );
            // return the result
            return ( mIndex < oth.mIndex );
        }
        bool operator>( const const_iterator& oth ) const
        {
            // make sure we have same parent buffer
            assert( oth.mBuffer == mBuffer );
            // return the result
            return ( mIndex > oth.mIndex );
        }
        bool operator<=( const const_iterator& oth ) const { return !( *this > oth ); }
        bool operator>=( const const_iterator& oth ) const { return !( *this < oth ); }

    protected:
        size_type mIndex;
        const Buffer* mBuffer;
    };

    template< typename T >
    class iterator
    : public const_iterator< T >
    {
        typedef const_iterator< T > _Base;

    public:
        typedef typename _Base::iterator_category iterator_category;
        typedef typename _Base::value_type        value_type;
        typedef typename _Base::difference_type   difference_type;
        typedef typename _Base::pointer           pointer;
        typedef typename _Base::const_pointer     const_pointer;
        typedef typename _Base::reference         reference;
        typedef typename _Base::const_reference   const_reference;

        iterator( Buffer* buffer = NULL, size_type index = 0 ) : _Base( buffer, index ) {}
        iterator( const iterator& oth ) : _Base( oth ) {}

        iterator& operator=( const iterator& oth ) { *(_Base*)this = oth; return *this; }

        template< typename T2 >
        iterator< T2 > As() const { return iterator< T2 >( _Base::mBuffer, _Base::mIndex ); }

        reference operator*() const { return const_cast< reference >( **(_Base*)this ); }
        pointer operator->() const { return &**this; }
        reference operator[]( difference_type diff ) const { return *( *this + diff ); }

        iterator operator+( difference_type diff ) const
        {
            iterator res( *this );
            return ( res += diff );
        }
        iterator operator+=( difference_type diff ) { *(_Base*)this += diff; return *this; }
        iterator& operator++() { ++*(_Base*)this; return *this; }
        iterator operator++( int )
        {
            iterator res( *this );
            ++*this;
            return res;
        }

        iterator operator-( difference_type diff ) const
        {
            iterator res( *this );
            return ( res -= diff );
        }
        iterator& operator-=( difference_type diff ) { *(_Base*)this -= diff; return *this; }
        iterator& operator--() { --*(_Base*)this; return *this; }
        iterator operator--( int )
        {
            iterator res( *this );
            --*this;
            return res;
        }

        difference_type operator-( const _Base& oth ) const { return ( *(_Base*)this - oth ); }
    };

    Buffer( size_type len = 0, const uint8& fill = 0 )
    : 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( Iter first, Iter last )
    : mBuffer( NULL ),
      mSize( 0 ),
      mCapacity( 0 )
    {
        // assign the content
        AssignSeq( first, last );
    }
    Buffer( const Buffer& oth )
    : mBuffer( NULL ),
      mSize( 0 ),
      mCapacity( 0 )
    {
        // Use assignment operator
        *this = oth;
    }
    ~Buffer()
    {
        // Free buffer
        SafeFree( mBuffer );
    }

    /********************************************************************/
    /* Read methods                                                     */
    /********************************************************************/
    template< typename T >
    iterator< T > begin() { return iterator< T >( this, 0 ); }
    template< typename T >
    const_iterator< T > begin() const { return const_iterator< T >( this, 0 ); }
    template< typename T >
    iterator< T > end() { return iterator< T >( this, size() ); }
    template< typename T >
    const_iterator< T > end() const { return const_iterator< T >( this, size() ); }

    template< typename T >
    T& Get( size_type index ) { return *( begin< T >() + index ); }
    template< typename T >
    const T& Get( size_type index ) const { return *( begin< T >() + index ); }

    uint8& operator[]( size_type index ) { return Get< uint8 >( index ); }
    const uint8& operator[]( size_type index ) const { return Get< uint8 >( index ); }

    /********************************************************************/
    /* Write methods                                                    */
    /********************************************************************/
    template< typename T >
    void Append( const T& value )
    {
        // 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 );
    }
    template< typename Iter >
    void AppendSeq( Iter first, Iter last )
    {
        // 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 );
    }

    template< typename T >
    void Assign( const T& value )
    {
        // 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 Iter >
    void AssignSeq( Iter first, Iter last )
    {
        // 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 );
        }
    }

    template< typename T >
    void AssignAt( const_iterator< T > index, const T& value )
    {
        // 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 AssignSeqAt( const_iterator< typename std::iterator_traits< Iter >::value_type > index, Iter first, Iter last )
    {
        // 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 );
        }
    }

    template< typename T >
    Buffer& operator<<( const T& value )
    {
        // append the value
        Append< T >( value );
        // return ourselves
        return *this;
    }
    template< typename T >
    Buffer& operator=( const T& value )
    {
        // assign the value
        Assign< T >( value );
        // return ourselves
        return *this;
    }
    Buffer& operator=( const Buffer& value )
    {
        // assign new content
        AssignSeq( value.begin< uint8 >(), value.end< uint8 >() );
        // return ourselves
        return *this;
    }

    /********************************************************************/
    /* Size methods                                                     */
    /********************************************************************/
    size_type size() const { return mSize; }
    size_type capacity() const { return mCapacity; }

    template< typename T >
    void Reserve( size_type requiredCount )
    {
        // reserve at beginning
        ReserveAt< T >( begin< T >(), requiredCount );
    }

    template< typename T >
    void ReserveAt( const_iterator< T > index, size_type requiredCount )
    {
        // 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 );
    }

    template< typename T >
    void Resize( size_type requiredCount, const uint8& fill = 0 )
    {
        // Resize at beginning
        ResizeAt< T >( begin< T >(), requiredCount, fill );
    }

    template< typename T >
    void ResizeAt( const_iterator< T > index, size_type requiredCount, const uint8& fill = 0 )
    {
        // 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 );
    }

protected:
    uint8* mBuffer;
    size_type mSize;
    size_type mCapacity;

    template< typename T >
    void _Resize( size_type requiredCount )
    {
        // resize at beginning
        _ResizeAt< T >( begin< T >(), requiredCount );
    }

    template< typename T >
    void _ResizeAt( const_iterator< T > index, size_type requiredCount )
    {
        // 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 );
    }

    void _Reallocate( size_type requiredSize )
    {
        // 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;
        }
    }

    static size_type _CalcBufferCapacity( size_type currentCapacity, size_type requiredSize )
    {
        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;
    }
};

#endif /* !__UTILS__BUFFER_H__INCL__ */