edlvector.h

Go to the documentation of this file.

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

 
#ifndef edlvector_h
#define edlvector_h
 
#include <cstdint>
#include <vector>
#include <initializer_list>
 
#include <edl/edltypes.h>
#include <edl/edlnamespaces.h>
#include <edl/edlallocator.h>
 
_BEGIN_EDL_NAMESPACE
 
EDL_API void throwVectorError();
 
template <class T, uint32_t STATICBUFFERLEN> class CEDLVectorIterator;
template <class T, uint32_t STATICBUFFERLEN> class CEDLVectorConstIterator;
 
template <class T, uint32_t STATICBUFFERLEN = 1>
class CEDLVector
{
public:
    typedef CEDLVectorIterator<T, STATICBUFFERLEN>             Iterator;
    typedef CEDLVectorConstIterator<T, STATICBUFFERLEN>        ConstIterator;
 
 
    // Copy constructor
    CEDLVector(const CEDLVector& incoming)
    {
        init();
        assign(incoming);
    }
 
    CEDLVector(const std::vector<T>& incoming)
    {
        init();
        assign(incoming);
    }
 
    CEDLVector(const std::initializer_list<T>& incoming)
    {
        init();
        assign(incoming);
    }
 
    // Allocate an empty vector
    CEDLVector(uint32_t size = 0)
    {
        init();
        if (size > 0)
        {
            resize(size);
        }
    }
 
    CEDLVector(uint32_t size, const T values[])
    {
        init();
        resize(size);
        for (uint32_t i = 0; i < size; i++)
        {
            m_vector[i] = values[i];
        }
    }
 
    virtual ~CEDLVector()
    {
        clear();
    }
 
    void clear()
    {
        resizeVector(0);
        m_vectorSize = 0;
    }
 
    void reserve(uint32_t reserveSize)
    {
        if (reserveSize > m_reservedSize)
        {
            resizeVector(reserveSize);
        }
    }
 
    // Return a std::vector equivalent
    std::vector<T> toVector()
    {
        std::vector<T>  vect;
 
        vect.reserve(m_vectorSize);
        for (uint32_t i = 0; i < m_vectorSize; i++)
            vect.push_back(m_vector[i]);
        return vect;
    }
 
    // Get size
    uint32_t size() const
    {
        return m_vectorSize;
    }
 
    bool empty() const
    {
        return m_vectorSize == 0;
    }
 
 
    // Dereference via index
    T& operator[](uint32_t index)
    {
        if (index >= m_vectorSize)
            throwVectorError();
 
        return m_vector[index];
    }
 
    bool operator== (const CEDLVector& other) const
    {
        if (m_vectorSize != other.m_vectorSize)
            return false;
 
        for (uint32_t i = 0; i < m_vectorSize; i++)
        {
            if (m_vector[i] != other.m_vector[i])
                return false;
        }
        return true;
    }
 
    bool operator!= (const CEDLVector& other) const
    {
        return !(*this == other);
    }
 
    T& operator[](uint32_t index) const
    {
        if (index >= m_vectorSize)
            throwVectorError();
 
        return m_vector[index];
    }
    
    const T *data() const
    {
        if (empty())
            throwVectorError();
        return m_vector;
    }
 
 
    T& last()
    {
        if (empty())
            throwVectorError();
 
        return m_vector[m_vectorSize - 1];
    }
 
    T& last() const
    {
        if (empty())
            throwVectorError();
 
        return m_vector[m_vectorSize - 1];
    }
 
    CEDLVector& operator= (const CEDLVector& incoming)
    {
        assign(incoming);
        return *this;
    }
 
    void reverse()
    {
        if (!m_vectorSize)
            return;
 
        for (uint32_t i = 0, x = m_vectorSize - 1; i < x; ++i, --x)
        {
            T cache = m_vector[i];
            m_vector[i] = m_vector[x];
            m_vector[x] = cache;
        }
    }
 
    void resize(uint32_t newSize)
    {
        if (newSize == m_vectorSize)
            return;
 
        if (newSize == 0 && m_vector)
        {
            clear();
        }
        else if (newSize > m_vectorSize && newSize <= m_reservedSize && m_vector)
        {
            for (uint32_t i = m_vectorSize; i < newSize; i++)
                new (m_vector + i) T();
        }
        else if (newSize < m_vectorSize && m_vector)
        {
            for (uint32_t i = newSize; i < m_vectorSize; i++)
                m_vector[i].~T();
        }
        else
        {
            uint32_t reserveSize = newSize;
            if (newSize > m_vectorSize)
            {
                reserveSize = m_vectorSize * 3 / 2;
                if (reserveSize < newSize)
                    reserveSize = newSize;
            }
 
            if (reserveSize > 0 && reserveSize < STATICBUFFERLEN)
            {
                reserveSize = STATICBUFFERLEN;
            }
 
            resizeVector(reserveSize);
            m_reservedSize = reserveSize;
            if (newSize > m_vectorSize)
            {
                for (uint32_t i = m_vectorSize; i < newSize; i++)
                    new (m_vector + i) T();
            }
        }
        m_vectorSize = newSize;
    }
 
    void append(const T& obj)
    {
        resize(m_vectorSize + 1);
        m_vector[m_vectorSize - 1] = obj;
    }
 
    void append(const CEDLVector& items)
    {
        uint32_t startPos = m_vectorSize;
        resize(m_vectorSize + items.size());
        for (uint32_t i = 0; i < items.size(); ++i)
        {
            m_vector[i + startPos] = items[i];
        }
    }
 
    void insert(uint32_t index, const T& obj)
    {
        if (index > m_vectorSize)
            throwVectorError();
 
        if (index == m_vectorSize)
        {
            append(obj);
        }
        else
        {
            resize(m_vectorSize + 1);
            for (uint32_t i = m_vectorSize - 1; i > index; i--)
            {
                m_vector[i] = m_vector[i - 1];
            }
            m_vector[index] = obj;
        }
    }
 
    void insert(uint32_t index, const CEDLVector& items)
    {
        for (uint32_t i = 0; i < items.size(); ++i)
        {
            insert(index++, items[i]);
        }
    }
 
    void fill(const T& obj)
    {
        for (uint32_t i = 0; i < m_vectorSize; i++)
        {
            m_vector[i] = obj;
        }
    }
 
    // Erase the entry at the given index, shortening the vector by one.
    void erase(uint32_t index)
    {
        if (index >= m_vectorSize)
            throwVectorError();
        for (uint32_t i = index + 1; i < m_vectorSize; i++)
            m_vector[i - 1] = m_vector[i];
        resize(m_vectorSize - 1);
    }
 
    // Find the specified entry in the collection, throwing if none found.
    // For a non-throwing equivalent, see find() below.
    uint32_t indexOf(const T& obj) const
    {
        for (uint32_t i = 0; i < m_vectorSize; i++)
        {
            if (m_vector[i] == obj)
            {
                return i;
            }
        }
        throwVectorError(); // Object not found.
        return (uint32_t)-1; // Should never be reached.
    }
 
    bool contains(const T& obj) const
    {
        for (uint32_t i = 0; i < m_vectorSize; i++)
        {
            if (m_vector[i] == obj)
            {
                return true;
            }
        }
        return false;
    }
 
    // An iterator that allows, amongst other things, C++11 ranged for syntax
    Iterator begin()
    {
        return Iterator(this, 0);
    }
 
    Iterator end()
    {
        return Iterator(this, m_vectorSize);
    }
 
    ConstIterator begin() const
    {
        return ConstIterator(this, 0);
    }
 
    ConstIterator end() const
    {
        return ConstIterator(this, m_vectorSize);
    }
 
    ConstIterator find(const T& obj) const
    {
        for (uint32_t i = 0; i < m_vectorSize; i++)
        {
            if (m_vector[i] == obj)
            {
                return ConstIterator(this, i);
            }
        }
        return end();
    }
    Iterator find(const T& obj)
    {
        for (uint32_t i = 0; i < m_vectorSize; i++)
        {
            if (m_vector[i] == obj)
            {
                return Iterator(this, i);
            }
        }
        return end();
    }
 
private:
    void init()
    {
        m_vector = NULL;
        m_vectorSize = 0;
        m_reservedSize = 0;
    }
 
    void assign(const CEDLVector& incoming)
    {
        uint32_t newSize = incoming.size();
 
        if (newSize != m_vectorSize)
        {
            resize(0);
            if (newSize > 0)
                resize(newSize);
        }
 
        for (uint32_t i = 0; i < newSize; i++)
        {
            m_vector[i] = incoming[i];
        }
    }
 
    void assign(const std::vector<T>& incoming)
    {
        uint32_t newSize = (uint32_t)incoming.size();
 
        if (newSize != m_vectorSize)
        {
            resize(0);
            if (newSize > 0)
                resize(newSize);
        }
 
        for (uint32_t i = 0; i < newSize; i++)
        {
            m_vector[i] = incoming[i];
        }
    }
 
    void assign(const std::initializer_list<T>& incoming)
    {
        uint32_t newSize = (uint32_t)incoming.size();
 
        if (newSize != m_vectorSize)
        {
            resize(0);
            if (newSize > 0)
            {
                resize(newSize);
            }
        }
 
        uint32_t i = 0;
        for (T element : incoming)
        {
            m_vector[i] = element;
            i++;
        }
    }
 
    // Change the size of the actual storage array
    void resizeVector(uint32_t newSize)
    {
        // We will impose a minimum reserved size of SBLEN
        if (newSize > 0 && STATICBUFFERLEN > 0 && newSize < STATICBUFFERLEN)
        {
            newSize = STATICBUFFERLEN;
        }
 
        if (newSize == m_reservedSize)
        {
            return;
        }
 
        T* newVect = nullptr;
        if (newSize > 0)
        {
            if (newSize == STATICBUFFERLEN)
            {
                newVect = (T*)m_staticVector;
            }
            else
            {
                newVect = (T*)m_allocator.allocate(sizeof(T) * newSize);
                if (!newVect) throwVectorError();
            }
            uint32_t cpSz = newSize > m_vectorSize ? m_vectorSize : newSize;
            for (uint32_t i = 0; i < cpSz; i++)
                new (newVect + i) T(m_vector[i]);
        }
        if (m_vector)
        {
            for (uint32_t i = 0; i < m_vectorSize; i++)
                m_vector[i].~T();
            if (m_vector != (T*)m_staticVector)
            {
                m_allocator.deallocate(m_vector);
            }
        }
        m_vector = newVect;
        m_reservedSize = newSize;
    }
 
    T* m_vector;
    // Ensure at least eight byte alignment for static storage
    uint64_t        m_staticVector[(sizeof(T) * STATICBUFFERLEN + 7) / 8];
    uint32_t        m_vectorSize;
    uint32_t        m_reservedSize;
 
    EDLAllocator    m_allocator;
};
 
 
template <class T, uint32_t STATICBUFFERLEN = 1>
class CEDLVectorIterator
{
    friend class CEDLVector<T, STATICBUFFERLEN>;
    friend class CEDLVectorConstIterator<T, STATICBUFFERLEN>;
 
public:
    CEDLVectorIterator(CEDLVector<T, STATICBUFFERLEN>* vector = nullptr, uint32_t index = 0) : m_vector(vector), m_index(index)
    {
    }
    CEDLVectorIterator(const CEDLVectorIterator& other) : m_vector(other.m_vector), m_index(other.m_index)
    {
    }
 
    CEDLVectorIterator& operator= (const CEDLVectorIterator& incoming)
    {
        m_vector = incoming.m_vector;
        m_index = incoming.m_index;
        return *this;
    }
 
    bool operator!= (const CEDLVectorIterator& other) const
    {
        return (m_vector != other.m_vector || m_index != other.m_index);
    }
    bool operator== (const CEDLVectorIterator& other) const
    {
        return m_vector == other.m_vector && m_index == other.m_index;
    }
    T& operator* ()
    {
        if (!m_vector)
        {
            throwVectorError();
        }
        return (*m_vector)[m_index];
    }
    T* operator->()
    {
        if (!m_vector)
        {
            throwVectorError();
        }
        return &(*m_vector)[m_index];
    }
    const CEDLVectorIterator& operator++()
    {
        m_index++;
        return *this;
    }
    const CEDLVectorIterator operator++(int)
    {
        CEDLVectorIterator result(*this);
        m_index++;
        return result;
    }
    // Obtain the index of the iterator
    uint32_t getIndex() const
    {
        return m_index;
    }
 
 
    // These functions moveNext(), hasCurrentValue(), and currentValue()
    // are for an alternate way to loop through the enumeration when
    // you don't have the original vector object check if you've reached the end.
    //
    // In C++ the loop goes something like this :
    //
    //    for (var iter = vect.begin (); iter != vect.end (); iter++)
    //        val = *iter;
    //
    // However if you don't have the original object you can't compare the end
    // so an alternative loop would look like this :
    //
    //    for (var iter = vect.begin (); iter.hasCurrentValue (); iter.moveNext ())
    //        val = iter.currentValue ();
 
    void moveNext()
    {
        m_index++;
    }
 
    bool hasCurrentValue() const
    {
        return m_index < m_vector->size();
    }
 
    T currentValue() const
    {
        if (!m_vector
            || (m_index >= m_vector->size())
            )
        {
            throwVectorError();
        }
        return (*m_vector)[m_index];
    }
 
private:
    CEDLVector<T, STATICBUFFERLEN>* m_vector;
    uint32_t    m_index;
};
 
template <class T, uint32_t STATICBUFFERLEN = 1>
class CEDLVectorConstIterator
{
    friend class CEDLVector<T, STATICBUFFERLEN>;
    friend class CEDLVectorIterator<T, STATICBUFFERLEN>;
 
public:
    CEDLVectorConstIterator(const CEDLVector<T, STATICBUFFERLEN>* vector = nullptr, uint32_t index = 0) : m_vector(vector), m_index(index)
    {
    }
 
    CEDLVectorConstIterator(const CEDLVectorConstIterator& other) : m_vector(other.m_vector), m_index(other.m_index)
    {
    }
 
    CEDLVectorConstIterator(const CEDLVectorIterator<T, STATICBUFFERLEN>& other) : m_vector(other.m_vector), m_index(other.m_index)
    {
    }
 
    CEDLVectorConstIterator& operator= (const CEDLVectorConstIterator& incoming)
    {
        m_vector = incoming.m_vector;
        m_index = incoming.m_index;
        return *this;
    }
 
    bool operator!= (const CEDLVectorConstIterator& other) const
    {
        return (m_vector != other.m_vector) || (m_index != other.m_index);
    }
 
    bool operator== (const CEDLVectorConstIterator& other) const
    {
        return (m_vector == other.m_vector) && (m_index == other.m_index);
    }
 
    const T& operator* () const
    {
        if (!m_vector)
        {
            throwVectorError();
        }
        return (*m_vector)[m_index];
    }
 
    const T* operator->() const
    {
        if (!m_vector)
        {
            throwVectorError();
        }
        return &(*m_vector)[m_index];
    }
 
    const CEDLVectorConstIterator& operator++()
    {
        m_index++;
        return *this;
    }
 
    CEDLVectorConstIterator operator++(int)
    {
        CEDLVectorConstIterator result(*this);
        m_index++;
        return result;
    }
    // Obtain the index of the iterator
    uint32_t getIndex() const
    {
        return m_index;
    }
 
    void moveNext()
    {
        m_index++;
    }
 
    bool hasCurrentValue() const
    {
        return m_index < m_vector->size();
    }
 
    T currentValue() const
    {
        if (!m_vector
            || (m_index >= m_vector->size())
            )
        {
            throwVectorError();
        }
        return (*m_vector)[m_index];
    }
 
private:
    const CEDLVector<T, STATICBUFFERLEN>* m_vector;
    uint32_t    m_index;
};
 
_END_EDL_NAMESPACE
 
#endif