unordered_ref_array.h

#pragma once
#include <vector>

template <typename T>
class unordered_ref_array
{
public:
    // ------------------------------------------
    // Iterators
    // ------------------------------------------
    typedef std::vector<T>  base_class_type;
    typedef typename base_class_type::iterator iterator;
    typedef typename base_class_type::const_iterator const_iterator;
                     
    typedef typename base_class_type::reverse_iterator reverse_iterator;
    typedef typename base_class_type::const_reverse_iterator const_reverse_iterator;

    iterator begin() { return m_data.begin(); }
    const_iterator begin() const { return m_data.begin(); }

    iterator end() { return m_data.end(); }
    const_iterator end() const { return m_data.end(); }

    const_iterator cbegin() const { return m_data.cbegin(); }
    const_iterator cend() const { return m_data.cend(); }

    reverse_iterator rbegin() { return m_data.rbegin(); }
    const_reverse_iterator rbegin() const { return m_data.rbegin(); }

    reverse_iterator rend() { return m_data.rend(); }
    const_reverse_iterator rend() const { return m_data.rend(); }

    const_reverse_iterator crbegin() const { return m_data.crbegin(); }
    const_reverse_iterator crend() const { return m_data.crend(); }

    unordered_ref_array<T>()
        : m_data()
    {
    }

    explicit unordered_ref_array<T>(size_t capacity)
        : m_data()
    {
        reserve(capacity);
    }

    ~unordered_ref_array<T>()
    {
        clear();
    }

    unordered_ref_array<T>(const unordered_ref_array<T>& other)
    {
        m_data = other.m_data;
        addRefForAllObjects();
    }

    unordered_ref_array<T>(unordered_ref_array<T>&& other)
    {
        m_data = std::move(other._data);
    }

    unordered_ref_array<T>& operator=(const unordered_ref_array<T>& other)
    {
        if (this != &other) {
            clear();
            m_data = other.m_data;
            addRefForAllObjects();
        }
        return *this;
    }

    unordered_ref_array<T>& operator=(unordered_ref_array<T>&& other)
    {
        if (this != &other) {
            clear();
            m_data = std::move(other._data);
        }
        return *this;
    }

    void reserve(size_t n)
    {
        m_data.reserve(n);
    }

    size_t capacity() const
    {
        return m_data.capacity();
    }

    size_t size() const
    {
        return  m_data.size();
    }

    bool empty() const
    {
        return m_data.empty();
    }

    size_t max_size() const
    {
        return m_data.max_size();
    }

    size_t getIndex(T object) const
    {
        auto iter = std::find(m_data.begin(), m_data.end(), object);
        if (iter != m_data.end())
            return iter - m_data.begin();

        return -1;
    }

    const_iterator find(T object) const
    {
        return std::find(m_data.begin(), m_data.end(), object);
    }

    iterator find(T object)
    {
        return std::find(m_data.begin(), m_data.end(), object);
    }

    T at(size_t index) const
    {
        PE_ASSERT(index >= 0 && index < size());
        return m_data[index];
    }

    T front() const
    {
        return m_data.front();
    }

    T back() const
    {
        return m_data.back();
    }

    bool contains(T object) const
    {
        return(std::find(m_data.begin(), m_data.end(), object) != m_data.end());
    }

    bool equals(const unordered_ref_array<T> &other)
    {
        size_t s = this->size();
        if (s != other.size())
            return false;

        for (size_t i = 0; i < s; i++)
        {
            if (this->at(i) != other.at(i))
            {
                return false;
            }
        }
        return true;
    }

    // Adds objects

    void push_back(T object)
    {
        PE_ASSERT(object != nullptr);
        m_data.push_back(object);
        object->addref();
    }

    void push_back(const unordered_ref_array<T>& other)
    {
        for (const auto &obj : other) {
            m_data.push_back(obj);
            obj->addref();
        }
    }

    void insert(size_t index, T object)
    {
        PE_ASSERT(index >= 0 && index <= size());
        PE_ASSERT(object != nullptr);
        m_data.insert((std::begin(m_data) + index), object);
        object->addref();
    }

    // Removes Objects

    void pop_back()
    {
        PE_ASSERT(!m_data.empty());
        auto last = m_data.back();
        m_data.pop_back();
        last->Release();
    }

    void eraseObject(T object, bool removeAll = false)
    {
        PE_ASSERT(object != nullptr);

        if (removeAll)
        {
            for (auto iter = m_data.begin(); iter != m_data.end();)
            {
                if ((*iter) == object)
                {
                    iter = m_data.erase(iter);
                    object->Release();
                }
                else
                {
                    ++iter;
                }
            }
        }
        else
        {
            auto iter = std::find(m_data.begin(), m_data.end(), object);
            if (iter != m_data.end())
            {
                m_data.erase(iter);
                object->Release();
            }
        }
    }

    iterator erase(iterator position)
    {
        PE_ASSERT(position >= m_data.begin() && position < m_data.end());
        (*position)->Release();
        size_t nIndex = position - m_data.begin();
        // move the last element to current position. 
        *position = m_data.back();
        m_data.pop_back();
        
        return !m_data.empty() ? (m_data.begin()+nIndex) : m_data.end();
    }

    iterator erase(iterator first, iterator last)
    {
        for (auto iter = first; iter != last; ++iter)
        {
            (*iter)->Release();
        }

        return m_data.erase(first, last);
    }

    iterator erase(size_t index)
    {
        PE_ASSERT(!m_data.empty() && index >= 0 && index < size());
        auto it = std::next(begin(), index);
        (*it)->Release();
        *it = m_data.back();
        m_data.pop_back();
        return !m_data.empty() ? (m_data.begin()+index) : m_data.end();
    }

    void clear()
    {
        for (auto it = std::begin(m_data); it != std::end(m_data); ++it) {
            (*it)->Release();
        }
        m_data.clear();
    }

    // Rearranging Content

    void swap(T object1, T object2)
    {
        size_t idx1 = getIndex(object1);
        size_t idx2 = getIndex(object2);

        PE_ASSERT(idx1 >= 0 && idx2 >= 0);

        std::swap(m_data[idx1], m_data[idx2]);
    }

    void swap(size_t index1, size_t index2)
    {
        PE_ASSERT(index1 >= 0 && index1 < size() && index2 >= 0 && index2 < size());

        std::swap(m_data[index1], m_data[index2]);
    }

    void replace(size_t index, T object)
    {
        PE_ASSERT(index >= 0 && index < size());
        PE_ASSERT(object != nullptr);

        m_data[index]->Release();
        m_data[index] = object;
        object->addref();
    }

    void reverse()
    {
        std::reverse(std::begin(m_data), std::end(m_data));
    }

    void shrink_to_fit()
    {
        m_data.shrink_to_fit();
    }

protected:

    void addRefForAllObjects()
    {
        for (const auto &obj : m_data) {
            obj->addref();
        }
    }

    base_class_type m_data;
};