edlsimplebuffer.h

Go to the documentation of this file.

/*
 * edlsimplebuffer.h
 *
 * Copyright (C) 2009-2026 Hybrid Software Helix Ltd. All rights reserved.
 */

 
#ifndef edlsimplebuffer_h
#define edlsimplebuffer_h
 
#include <stdlib.h>
#include <cstring>
#include <edl/edltypes.h>
#include <edl/edlnamespaces.h>
#include <edl/edlerrors.h>
 
_BEGIN_EDL_DOM_NAMESPACE
 
class CEDLSimpleBuffer
{
  public:
    // Copy constructor
    CEDLSimpleBuffer(const CEDLSimpleBuffer &incoming)
    {
        init();
        assign(incoming.m_buffer, incoming.m_bufferSize);
    }
 
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE { const uint8 *src};
#endif
#if SWIGCSHARP
    %apply uint8_t INPUT[] { const uint8 *src};
#endif
#if SWIGPYTHON
    %apply char INPUT[] {const uint8 *src}
#endif
#endif
    // Allocate from a pre-existing block
    CEDLSimpleBuffer(const uint8 *src, size_t size)
    {
        init();
        assign(src, size);
    }
#ifdef SWIG
    %clear const uint8 *src;
#endif
 
    // Allocate an empty block
    CEDLSimpleBuffer(size_t size = 0, bool clearBuff = false)
    {
        init();
        resize(size);
        if (clearBuff)
            clear();
    }
 
    ~CEDLSimpleBuffer()
    {
        release();
    }
 
    // Get size
    size_t size() const
    {
        return m_bufferSize;
    }
 
    // Dereference via index
    uint8& operator[](size_t index)
    {
        if (index >= m_bufferSize)
        {
            throwEDLError(JM_ERR_RANGE_ERROR);
        }
        return m_buffer[index];
    }
 
    const uint8& operator[](size_t index) const
    {
        if (index >= m_bufferSize)
        {
            throwEDLError(JM_ERR_RANGE_ERROR);
        }
        return m_buffer[index];
    }
 
    CEDLSimpleBuffer& operator=(const CEDLSimpleBuffer &incoming)
    {
        release();
        assign(incoming.m_buffer, incoming.m_bufferSize);
        return *this;
    }
 
    void resize(size_t newSize)
    {
#ifdef SWIG
        // > 32bit indexes are not currently supported for SWIG builds
        if (newSize != (uint32) newSize)
        {
            throwEDLError(EDL_ERR_BAD_ARGUMENTS);
        }
#endif
        // Need to free?
        if (!newSize && m_buffer)
        {
            release();
        }
        // Need to allocate?
        else if (!m_buffer && newSize != 0)
        {
            m_buffer = (uint8 *) m_allocate(newSize);
            if (!m_buffer)
            {
                throwEDLError(EDL_ERR_OUTOFMEMORY);
            }
        }
        // Need to resize?
        else if (newSize != m_bufferSize)
        {
            uint8 *newBuffer = (uint8 *) m_reallocate(m_buffer, newSize);
            if (!newBuffer)
            {
                throwEDLError(EDL_ERR_OUTOFMEMORY);
            }
            m_buffer = newBuffer;
        }
        m_bufferSize = newSize;
 
    }
 
    void clear()
    {
        if (m_buffer && m_bufferSize)
        {
            memset(m_buffer, 0, m_bufferSize);
        }
    }
 
private:
 
    void init()
    {
        m_buffer = NULL;
        m_bufferSize = 0;
        m_allocate = malloc;
        m_deallocate = free;
        m_reallocate = realloc;
    }
 
    void assign(const uint8 *src, size_t size)
    {
        resize(size);
        if (size)
        {
            memcpy(m_buffer, src, size);
        }
    }
 
    void release()
    {
        if (m_buffer)
            m_deallocate(m_buffer);
        m_buffer = NULL;
        m_bufferSize = 0;
    }
 
    uint8 *m_buffer;
    size_t m_bufferSize;
 
    typedef void *(*AllocatorFn)(size_t n);
    typedef void (*DeallocatorFn)(void *p);
    typedef void *(*ReallocatorFn)(void *p, size_t newSize);
 
    AllocatorFn   m_allocate;
    DeallocatorFn m_deallocate;
    ReallocatorFn m_reallocate;
};
 
_END_EDL_DOM_NAMESPACE
 
#endif