ByteBuffer.h

#ifndef CARMA_UTIL_BYTEBUFFER_H
#define CARMA_UTIL_BYTEBUFFER_H

#include <algorithm>


namespace carma {
namespace util {


class ByteBuffer {
    public:
        explicit ByteBuffer( );

        ~ByteBuffer( );

        void swap( ByteBuffer & rhs );
        
        char * get( ) const;
        
        size_t size( ) const;
        
        size_t reserve( ) const;
        
        void destructiveReserve( size_t count );
        
        void destructiveResize( size_t count );
        
    private:
        ByteBuffer( const ByteBuffer & rhs );
        ByteBuffer & operator=( const ByteBuffer & rhs );

        void internalFree( );
        void internalDestructiveReserve( size_t count );
        
        char * ptr_;
        size_t allocSize_;
        size_t presentSize_;
};


}  // namespace carma::util
}  // namespace carma


// ******* Below here is simply implementation *******


inline
carma::util::ByteBuffer::ByteBuffer( ) :
ptr_( 0 ),
allocSize_( 0 ),
presentSize_( 0 )
{
}


inline
carma::util::ByteBuffer::~ByteBuffer( )
{
    if ( ptr_ != 0 )
        internalFree();
}


inline void
carma::util::ByteBuffer::swap( ByteBuffer & rhs )
{
    ::std::swap( ptr_, rhs.ptr_ );
    ::std::swap( allocSize_, rhs.allocSize_ );
    ::std::swap( presentSize_, rhs.presentSize_ );
}


inline char *
carma::util::ByteBuffer::get( ) const
{
    return ptr_;
}


inline size_t
carma::util::ByteBuffer::size( ) const
{
    return presentSize_;
}


inline size_t
carma::util::ByteBuffer::reserve( ) const
{
    return allocSize_;
}


inline void
carma::util::ByteBuffer::destructiveReserve( const size_t count )
{
    if ( count > allocSize_ )
        internalDestructiveReserve( count );
}


inline void
carma::util::ByteBuffer::destructiveResize( const size_t count )
{
    if ( count > allocSize_ )
        internalDestructiveReserve( count );

    presentSize_ = count;
}


#endif