UTBuffer.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// This program is free software; you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, version 2.0 of the
// License.
//
// 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
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with this program; if
// not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


#ifndef _UT_BUFFER_H_
#define _UT_BUFFER_H_


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UT.h"


//==================================================================================================
class UT_EXPORT Buffer_t
//==================================================================================================
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline              Buffer_t();

    inline              Buffer_t( byte* stack_buffer, int stack_buffer_size );

    inline              ~Buffer_t();

    inline byte*        Buffer( int size, bool expect_more_growth = false );

    inline void         InstallStackBuffer( byte* stack_buffer, int stack_buffer_size );

    inline const byte*  ReadOnlyBuffer() const;

    inline byte&        operator [](int index);

    inline byte         ByteAt(int index) const;

    inline int          ValidSize() const;

    inline void         SetValidSize(int size);

    inline int          AllocatedSize() const;

    inline void         GrowIfNeeded( int min_allocated_bytes, bool expect_more_growth = false );

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    void                Reallocate( int size, bool expect_more_growth );
                            // Used internally to reallocate the buffer.  The buffer size must be
                            // greater than what is presently allocated.

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    byte*               m_buffer;
    int                 m_size;
    int                 m_valid;
    bool                m_buffer_from_stack;
};


//==================================================================================================
template <class T>
class SimpleTypedBuffer_t
//==================================================================================================
: private Buffer_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline              SimpleTypedBuffer_t();

    inline              SimpleTypedBuffer_t( T* stack_buffer, int num_elements );

    inline void         InstallStackBuffer( T* stack_buffer, int num_elements );

    inline T*           ItemBuffer( int num_elements, bool expect_more_growth = false );

    inline const T*     ReadOnlyItemBuffer() const;

    inline T&           operator [](int index);

    inline const T&     ItemAt(int index) const;

    inline int          NumValidItems() const;

    inline void         SetNumValidItems(int count);

    inline int          AllocatedItems() const;

    inline void         GrowIfNeeded( int min_allocated_items, bool expect_more_growth = false );
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations: class Buffer_t
//===
//==================================================================================================
//==================================================================================================
inline
Buffer_t::Buffer_t()
{
    m_buffer = NULL;
    m_size = 0;
    m_valid = 0;
    m_buffer_from_stack = false;
}


inline
Buffer_t::Buffer_t( byte* stack_buffer, int stack_buffer_size )
{
    m_buffer = stack_buffer;
    m_size = stack_buffer_size;
    m_valid = 0;
    m_buffer_from_stack = true;
}


inline
Buffer_t::~Buffer_t()
{
    if(m_buffer && !m_buffer_from_stack)
        delete[] m_buffer;
}


inline byte*
Buffer_t::Buffer( int size, bool expect_more_growth )
{
    if(size > m_size)
        Reallocate( size, expect_more_growth );
    if(m_valid < size)
        m_valid = size;
    return m_buffer;
}


inline void
Buffer_t::InstallStackBuffer( byte* stack_buffer, int stack_buffer_size )
{
    if(m_buffer && !m_buffer_from_stack)
        delete[] m_buffer;
    m_buffer = stack_buffer;
    m_size = stack_buffer_size;
    m_valid = 0;
    m_buffer_from_stack = true;
}


inline const byte*
Buffer_t::ReadOnlyBuffer() const
{
    return m_buffer;
}


inline byte&
Buffer_t::operator [](int index)
{
    if(index >= m_size)
        Reallocate( index+1, true );
    if(m_valid <= index)
        m_valid = index+1;
    return m_buffer[index];
}


inline byte
Buffer_t::ByteAt(int index) const
{
    assert(index < m_valid);
    return m_buffer[index];
}


inline int
Buffer_t::ValidSize() const
{
    return m_valid;
}


inline void
Buffer_t::SetValidSize(int size)
{
    assert(size >= 0 && size <= m_size);
    m_valid = size;
}


inline int
Buffer_t::AllocatedSize() const
{
    return m_size;
}


inline void
Buffer_t::GrowIfNeeded( int min_allocated_bytes, bool expect_more_growth )
{
    if(m_size < min_allocated_bytes)
        Reallocate( min_allocated_bytes, expect_more_growth );
}




//==================================================================================================
//==================================================================================================
//===
//=== Template function implementations: class SimpleTypedBuffer_t
//===
//==================================================================================================
//==================================================================================================
template <class T>
inline
SimpleTypedBuffer_t<T>::SimpleTypedBuffer_t()
: Buffer_t()
{ }


template <class T>
inline
SimpleTypedBuffer_t<T>::SimpleTypedBuffer_t( T* stack_buffer, int num_elements )
: Buffer_t( reinterpret_cast<byte*>(stack_buffer), num_elements * sizeof(T) )
{ }


template <class T>
inline void
SimpleTypedBuffer_t<T>::InstallStackBuffer( T* stack_buffer, int num_elements )
{
    Buffer_t::InstallStackBuffer( reinterpret_cast<byte*>(stack_buffer), num_elements * sizeof(T) );
}


template <class T>
inline T*
SimpleTypedBuffer_t<T>::ItemBuffer( int num_elements, bool expect_more_growth )
{
    return reinterpret_cast<T*>( Buffer( num_elements * sizeof(T), expect_more_growth ) );
}


template <class T>
inline const T*
SimpleTypedBuffer_t<T>::ReadOnlyItemBuffer() const
{
    return reinterpret_cast<const T*>( Buffer_t::ReadOnlyBuffer() );
}


template <class T>
inline T&
SimpleTypedBuffer_t<T>::operator [](int index)
{
    return reinterpret_cast<T*>( Buffer( (index+1) * sizeof(T), true ) )[index];
}


template <class T>
inline const T&
SimpleTypedBuffer_t<T>::ItemAt(int index) const
{
    assert( ValidSize() >= (index+1) * sizeof(T) );
    return reinterpret_cast<T*>( ReadOnlyBuffer() )[index];
}


template <class T>
inline int
SimpleTypedBuffer_t<T>::NumValidItems() const
{
    return ValidSize() / sizeof(T);
}


template <class T>
inline void
SimpleTypedBuffer_t<T>::SetNumValidItems(int count)
{
    Buffer_t::SetValidSize( count * sizeof(T) );
}


template <class T>
inline int
SimpleTypedBuffer_t<T>::AllocatedItems() const
{
    return Buffer_t::AllocatedSize() / sizeof(T);
}


template <class T>
inline void
SimpleTypedBuffer_t<T>::GrowIfNeeded( int min_allocated_items, bool expect_more_growth )
{
    Buffer_t::GrowIfNeeded( min_allocated_items * sizeof(T), expect_more_growth );
}


#endif // _UT_BUFFER_H_