cel_memory.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_memory_h_
#define _cel_memory_h_

#include "cel_types.h"
#include "cel_datatraits.h"
#include "cel_exception.h"
#include <new>
#include <cstring>

namespace Celartem
{
    //------------------------------------------------------------------------
    template<size_t ALIGN, class Int> Int align(Int sz)
    {
        return (sz + ((Int)ALIGN - 1)) & ~((Int)ALIGN - 1);
    }

    //------------------------------------------------------------------------
    class MemoryAllocator
    {
    public:
        //--------------------------------------------------------------------
        virtual CEL_RESTRICT_RETVAL void *allocate(size_t inBlockSize) = 0;

        //--------------------------------------------------------------------
        virtual void free(void *inMemoryBlockPtr) = 0;

        //--------------------------------------------------------------------
        static MemoryAllocator *getDefault();

        //--------------------------------------------------------------------
        static void setDefault(MemoryAllocator *inAllocator);

        //--------------------------------------------------------------------
        virtual ~MemoryAllocator() {}
    };

    //------------------------------------------------------------------------
    template<typename T, CopyPolicy copyPolicy> struct MemoryCopy;

    //------------------------------------------------------------------------
    template<typename T> struct MemoryCopy<T, byConstructor>
    {
        //--------------------------------------------------------------------
        void operator()(
            T * CEL_RESTRICT dest, const T * CEL_RESTRICT src, size_t count)
        {
            for(size_t i = 0; i < count; i++)
                *dest++ = *src++;
        }
    };

    //------------------------------------------------------------------------
    template<typename T> struct MemoryCopy<T, byMemcpy>
    {
        void operator()(
            T * CEL_RESTRICT dest, const T * CEL_RESTRICT src, size_t count)
        {
            std::memcpy(dest, src, sizeof(T) * count);
        }
    };

    //------------------------------------------------------------------------
    template<typename T> struct MemoryCopy<T, noCopy>
    {
        void operator()(
            T * CEL_RESTRICT dest, const T * CEL_RESTRICT src, size_t count)
        {
            // The class does not allow duplication of instances.
            celThrow2(
                errNotPermitted,
                "The class does not allow duplication of instances.");
        }
    };

    //------------------------------------------------------------------------
    template<typename T, CopyPolicy copyPolicy> struct MemoryMove;

    //------------------------------------------------------------------------
    template<typename T> struct MemoryMove<T, byConstructor>
    {
        //--------------------------------------------------------------------
        void operator()(
            T * dest, const T * src, size_t count)
        {
            if(dest < src)
            {
                for(size_t i = 0; i < count; i++)
                    *dest++ = *src++;
            }
            else
            {
                dest += count;
                src += count;
                for(size_t i = 0; i < count; i++)
                    *(--dest) = *(--src);
            }
        }
    };

    //------------------------------------------------------------------------
    template<typename T> struct MemoryMove<T, byMemcpy>
    {
        void operator()(
            T * dest, const T * src, size_t count)
        {
            std::memmove(dest, src, sizeof(T) * count);
        }
    };

    //------------------------------------------------------------------------
    template<typename T> struct MemoryMove<T, noCopy>
    {
        void operator()(
            T * dest, const T * src, size_t count)
        {
            // The class does not allow duplication of instances.
            celThrow2(
                errNotPermitted,
                "The class does not allow move of instances.");
        }
    };

    //------------------------------------------------------------------------
    template<typename T> struct MemoryFill
    {
        void operator()(T *buffer, size_t count, const T& t)
        {
            for(size_t i = 0; i < count; i++)
                *buffer++ = t;
        }
    };

    //------------------------------------------------------------------------
    template<> struct MemoryFill<int8_t>
    {
        void operator()(int8_t *buffer, size_t count, const int8_t& t)
        {
            std::memset(buffer, t, count);
        }
    };

    //------------------------------------------------------------------------
    template<> struct MemoryFill<uint8_t>
    {
        void operator()(uint8_t *buffer, size_t count, const uint8_t& t)
        {
            std::memset(buffer, t, count);
        }
    };

    //------------------------------------------------------------------------
    template<class T, CopyPolicy copyPolicy = DataTraits<T>::copyPolicy>
    class SimpleArray
    {
    public:
        static const size_t AUTO_SIZE = (size_t)0-1;

        //--------------------------------------------------------------------
        SimpleArray(
            size_t inSize = 0, size_t inReserve = AUTO_SIZE,
            MemoryAllocator *inAllocator = NULL,
            size_t inAllocationUnit = 0)
            :
            m_array(NULL), m_size(0), m_realSize(0), m_strictCleanup(false),
            m_alloc(inAllocator ? inAllocator : MemoryAllocator::getDefault())
        {
            setAllocationUnit(inAllocationUnit);
            allocate(inSize, inReserve);
        }

        //--------------------------------------------------------------------
        SimpleArray(const SimpleArray& inSa)
            : m_array(NULL), m_size(0), m_realSize(0)
        {
            duplicate(inSa);
        }

        //--------------------------------------------------------------------
        ~SimpleArray()
        {
            free();
        }

        //--------------------------------------------------------------------
        void init(size_t inSize = 0, size_t inReserve = 0,
            MemoryAllocator *inAllocator = NULL,
            size_t inAllocationUnit = 0)
        {
            free();
            m_alloc
                = inAllocator ? inAllocator : MemoryAllocator::getDefault();
            setAllocationUnit(inAllocationUnit);
            allocate(inSize, inReserve);
        }

        //--------------------------------------------------------------------
        SimpleArray& operator=(const SimpleArray& inSa)
        {
            duplicate(inSa);
            return *this;
        }

        //--------------------------------------------------------------------
        void strictCleanup(bool doIt = true)
        {
            m_strictCleanup = doIt;
        }
        
        //--------------------------------------------------------------------
        void setAllocationUnit(size_t inAllocationUnit)
        {
            if(inAllocationUnit)
                m_allocationUnit = inAllocationUnit;
            else
                m_allocationUnit = 128; // good enough?
        }
        
        //--------------------------------------------------------------------
        size_t getAllocationUnit()
        {
            return m_allocationUnit;
        }

        //--------------------------------------------------------------------
        T *getPtr()
        {
            if(_CEL_DEBUG_) healthCheck();
            return m_array;
        }

        //--------------------------------------------------------------------
        const T *getPtr() const
        {
            if(_CEL_DEBUG_) healthCheck();
            return m_array;
        }

        //--------------------------------------------------------------------
        size_t getSize() const {return m_size;}

        //--------------------------------------------------------------------
        size_t getReservedSize() const {return m_realSize;}

        //--------------------------------------------------------------------
        bool isValid() const
        {
            return m_array ? true : false;
        }

        //--------------------------------------------------------------------
        T& operator[](size_t inPos)
        {
            if(_CEL_DEBUG_) boundCheck(inPos);
            return m_array[inPos];
        }

        const T& operator[](size_t inPos) const
        {
            if(_CEL_DEBUG_) boundCheck(inPos);
            return m_array[inPos];
        }

        //--------------------------------------------------------------------
        void allocate(size_t inSize, size_t inReserve = AUTO_SIZE)
        {
            free();
            if(inSize == 0 && inReserve == 0)
                return;
            if(inReserve == AUTO_SIZE)
                inReserve = calc_realsize(inSize);
            _reserve(inReserve, inSize);
        }

        //--------------------------------------------------------------------
        void reserve(size_t inSize)
        {
            _reserve(inSize, m_size);
        }

        //--------------------------------------------------------------------
        void reallocate(size_t inSize)
        {
            if(inSize <= m_realSize)
            {
                _destruct(inSize, m_size);
                _construct(m_array, m_size, inSize);
                m_size = inSize;
            }
            else
            {
                size_t rsize = calc_realsize(inSize);
                _reserve(rsize, inSize);
            }
        }

        //--------------------------------------------------------------------
        inline void resize(size_t inSize) {reallocate(inSize);}

        //--------------------------------------------------------------------
        void compact()
        {
            if(m_size == 0)
            {
                free();
                return;
            }
            _reserve_no_restriction(m_size, m_size);
        }
        
        //--------------------------------------------------------------------
        void free()
        {
            if(m_array)
            {
                _destruct(0, m_size);
                m_alloc->free(m_array);
                m_array = NULL;
                m_size = m_realSize = 0;
            }
        }

        //--------------------------------------------------------------------
        void clear()
        {
            free();
        }
        
        //--------------------------------------------------------------------
        void remove(size_t inPos, size_t inCount)
        {
            size_t end = inPos + inCount;
            if(inPos > m_size || end > m_size)
                celThrow2(errInvalidParam,
                    "The range to remove is out of the array!");
            const size_t elemsToMove = m_size - end;
            MemoryMove<T, copyPolicy>()(
                m_array + inPos, m_array + end, elemsToMove);
            _destruct(m_size - inCount, m_size);
            m_size -= inCount;
        }

        //--------------------------------------------------------------------
        void insert(size_t inPos, size_t inCount)
        {
            if(inCount == 0)
                return;

            if(inPos > m_size)
                celThrow2(errInvalidParam,
                    "inPos out of the array!");
            
            const size_t newSize = m_size + inCount;
            if(newSize < m_realSize)
            {
                const size_t elemsToMove = m_size - inPos;
                _construct(m_array, m_size, m_size + inCount);
                MemoryMove<T, copyPolicy>()(
                    m_array + inPos + inCount, m_array + inPos, elemsToMove);
                _destruct(inPos, inPos + inCount);
                _construct(m_array, inPos, inPos + inCount);
                m_size += inCount;
                return;
            }
            
            size_t rsize = calc_realsize(newSize);
            T *temp = _malloc(rsize);
            if(copyPolicy == byMemcpy)
                _construct(temp, inPos, inPos + inCount);
            else
                _construct(temp, 0, newSize);

            MemoryCopy<T, copyPolicy>()(temp, m_array, inPos);
            MemoryCopy<T, copyPolicy>()(
                temp + inPos + inCount, m_array + inPos, m_size - inPos);

            free();
            m_array = temp;
            m_size = newSize;
            m_realSize = rsize;
        }

        //--------------------------------------------------------------------
        void insert(size_t inPos, size_t inCount, const T* inElements)
        {
            insert(inPos, inCount);
            for(size_t i = 0; i < inCount; i++)
                m_array[inPos + i] = inElements[i];
        }

        //--------------------------------------------------------------------
        void insert(size_t inPos, const SimpleArray& inElements)
        {
            insert(inPos, inElements.getSize(), &inElements[0]);
        }
        
        //--------------------------------------------------------------------
        void duplicate(const SimpleArray& inSa, bool inNeedCompaction = false)
        {
            free();
            m_alloc = inSa.m_alloc; // replace my memory allocator
            m_allocationUnit = inSa.m_allocationUnit;
            allocate(
                inSa.m_size,
                inNeedCompaction ? inSa.m_size : inSa.m_realSize);
            MemoryCopy<T, copyPolicy>()(m_array, inSa.m_array, inSa.m_size);
        }

        //--------------------------------------------------------------------
        void duplicate(const T *inBuffer, size_t inSize)
        {
            free();
            allocate(inSize);
            MemoryCopy<T, copyPolicy>()(m_array, inBuffer, inSize);
        }
        
        //--------------------------------------------------------------------
        void duplicate(
            const T *inBuffer, size_t inSize, Endian inEndian)
        {
            free();
            allocate(inSize);
            if(inEndian == endianHost)
                MemoryCopy<T, copyPolicy>()(m_array, inBuffer, inSize);
            else
            {
                for(size_t i = 0; i < inSize; i++)
                    m_array[i] = read<T>(&inBuffer[i], inEndian);
            }
        }

        //--------------------------------------------------------------------
        void fill(const T& t)
        {
            MemoryFill<T>()(m_array, m_size, t);
        }
        
        //--------------------------------------------------------------------
        template<typename U> void fill(const U& u)
        {
            MemoryFill<T>()(m_array, m_size, (const T)u);
        }

        //--------------------------------------------------------------------
        void zeroClear()
        {
            std::memset(m_array, 0, sizeof(T) * m_size);
        }

        //--------------------------------------------------------------------
        void swap(SimpleArray& inSa)
        {
            T *array = m_array;
            size_t size = m_size;
            size_t realSize = m_realSize;
            size_t resizeUnit = m_allocationUnit;
            bool strictCleanup = m_strictCleanup;
            MemoryAllocator *allocr = m_alloc;

            m_array = inSa.m_array;
            m_size = inSa.m_size;
            m_realSize = inSa.m_realSize;
            m_allocationUnit = inSa.m_allocationUnit;
            m_strictCleanup = inSa.m_strictCleanup;
            m_alloc = inSa.m_alloc;

            inSa.m_array = array;
            inSa.m_size = size;
            inSa.m_realSize = realSize;
            inSa.m_allocationUnit = resizeUnit;
            inSa.m_strictCleanup = strictCleanup;
            inSa.m_alloc = allocr;
        }

        //--------------------------------------------------------------------
        inline void push_back(const T& t)
        {
            size_t size = getSize();
            resize(size + 1);
            m_array[size] = t;
        }
        
        //--------------------------------------------------------------------
        template<typename U> void push_back(const U& t)
        {
            push_back((const T)t);
        }

        //--------------------------------------------------------------------
        inline T pop_back()
        {
            size_t size = getSize() - 1;
            T t = m_array[size];
            resize(size);
            return t;
        }

        //--------------------------------------------------------------------
        inline void push_front(const T& t)
        {
            insert(0, 1);
            m_array[0] = t;
        }
        
        //--------------------------------------------------------------------
        template<typename U> void push_front(const U& t)
        {
            push_front((const T)t);
        }

        //--------------------------------------------------------------------
        inline T pop_front()
        {
            T t = m_array[0];
            remove(0, 1);
            return t;
        }
        
        //--------------------------------------------------------------------
        T *begin()
        {
            if(_CEL_DEBUG_) healthCheck();
            return m_array;
        }

        //--------------------------------------------------------------------
        T *end()
        {
            if(_CEL_DEBUG_) healthCheck();
            return m_array + m_size;
        }

        //--------------------------------------------------------------------
        T *last()
        {
            if(_CEL_DEBUG_) boundCheck(m_size - 1);
            return m_array + m_size - 1;
        }

        //--------------------------------------------------------------------
        const T *begin() const
        {
            if(_CEL_DEBUG_) healthCheck();
            return m_array;
        }

        //--------------------------------------------------------------------
        const T *end() const
        {
            if(_CEL_DEBUG_) healthCheck();
            return m_array + m_size;
        }

        //--------------------------------------------------------------------
        const T *last() const
        {
            if(_CEL_DEBUG_) boundCheck(m_size - 1);
            return m_array + m_size - 1;
        }

        //--------------------------------------------------------------------
        T& front()
        {
            return *begin();
        }
        
        //--------------------------------------------------------------------
        const T& front() const
        {
            return *begin();
        }

        //--------------------------------------------------------------------
        T& back()
        {
            return *last();
        }

        //--------------------------------------------------------------------
        const T& back() const
        {
            return *last();
        }

    private:
        T *m_array;
        size_t m_size;
        size_t m_realSize;
        size_t m_allocationUnit;
        bool m_strictCleanup;
        MemoryAllocator *m_alloc;

        //--------------------------------------------------------------------
        // calc_realsize
        inline size_t calc_realsize(size_t inSize)
        {
            size_t res = inSize < m_allocationUnit ? m_allocationUnit : inSize;
            return inSize + res;
        }

        //--------------------------------------------------------------------
        static void _construct(T* inArray, size_t inStart, size_t inEnd)
        {
            // TODO: With some classes, we can implement more effecient
            // implementation such as std::memset.
            for(size_t i = inStart; i < inEnd; i++)
                new(&inArray[i]) T;
        }
        
        //--------------------------------------------------------------------
        void _destruct(size_t inStart, size_t inEnd)
        {
            // We wish the intelligent compilers can remove these
            // code on POD arrays.
            for(size_t i = inStart; i < inEnd; i++)
                m_array[i].~T(); // call destructor explicitly

            // zeroclear trailing garbages for security reasons
            if(m_strictCleanup && inStart < inEnd)
                std::memset(
                    &m_array[inStart], 0, (inEnd - inStart) * sizeof(T));
        }

        //--------------------------------------------------------------------
        CEL_RESTRICT_RETVAL T *_malloc(size_t inSize)
        {
            if(inSize >= 0x80000000)
                celThrow2(
                    errOperationFailed,
                    "SimpleArray: "
                    "The size of the memory block exceeds 2GB, "
                    "we could not deal with the request!");

            T *mem = (T *)m_alloc->allocate(sizeof(T) * inSize);
            if(!mem)
                celThrow2(
                    errOutOfMemory,
                    "SimpleArray: Out of memory!");
            return mem;
        }

        //--------------------------------------------------------------------
        // _reserve
        void _reserve(size_t inSize, size_t inSizeToInit)
        {
            if(inSize < m_realSize)
                return;
            
            _reserve_no_restriction(inSize, inSizeToInit);
        }
        
        //--------------------------------------------------------------------
        void _reserve_no_restriction(size_t inSize, size_t inSizeToInit)
        {
            T *temp = _malloc(inSize);
            if(copyPolicy != byMemcpy)
                _construct(temp, 0, inSizeToInit);

            // move the entries to new array
            if(m_size)
                MemoryCopy<T, copyPolicy>()(
                    temp, m_array, m_size);

            free();
            m_array = temp;
            m_size = inSizeToInit;
            m_realSize = inSize;
        }

        //--------------------------------------------------------------------
        // We should implement some health checking code here, which will
        // be called by debug version of SimpleArray.
        void healthCheck() const
        {
        }

        //--------------------------------------------------------------------
        // This code do validation of the array subscript.
        void boundCheck(size_t inPos) const
        {
            if(inPos == 0)
                return; // special case

            if(!m_array)
                celThrow2(errInternalError, "SimpleArray: m_array==NULL!");

            // some of the code may use &buf[0] to get the pointer to the
            // array regardless of the validity of it since such process
            // firstly checks the length of buffer. So we should ignore cases
            // with inPos = 0.
            if(inPos >= m_size)
                celThrow2(errInvalidParam,
                    "SimpleArray: subscript out of range");
        }
    };

} // namespace Celartem

#endif // _cel_memory_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.