vector.h

Go to the documentation of this file.

 
#ifndef MAXOS_COMMON_VECTOR_H
#define MAXOS_COMMON_VECTOR_H
 
#include <cstdint>
#include <cstddef>
 
 
namespace MaxOS::common {
 
    template<class Type> class VectorIterationHandler {
        public:
            VectorIterationHandler();
            ~VectorIterationHandler() = default;
 
            virtual void on_read(Type);
            virtual void on_end_of_stream();
    };
 
    template<class Type> class Vector {
        protected:
            Type* m_elements;                   
            uint32_t m_size { 0 };              
            uint32_t m_capacity { 1 };          
 
        public:
            typedef Type* iterator;             
 
            Vector();
            Vector(int size, Type element);
            Vector(const Vector<Type>& other);
            Vector(Vector<Type>&& other);
            ~Vector();
 
            Type& operator [](uint32_t index) const;
            Vector<Type>& operator =(const Vector<Type>& other);
            Vector<Type>& operator =(Vector<Type>&& other);
 
            [[nodiscard]] bool empty() const;
            [[nodiscard]] uint32_t size() const;
 
            iterator begin() const;
            iterator end() const;
            iterator find(Type) const;
 
            iterator push_back(Type);
            Type pop_back();
 
            iterator push_front(Type);
            Type pop_front();
 
            void erase(Type);
            void erase(typename Vector<Type>::iterator position);
            void clear();
 
            void reserve(size_t amount);
            void increase_size();
 
            void iterate(VectorIterationHandler<Type>*);
            void iterate(void callback(Type&));
    };
 
 
    template<class Type> Vector<Type>::Vector() {
 
        // Allocate space for the array
        m_elements = new Type[m_capacity];
 
    }
 
    template<class Type> Vector<Type>::Vector(int size, Type element) {
 
        // Allocate space for the array
        m_elements = new Type[size];
        m_capacity = size > 0 ? size : 1;
        m_size = 0;
 
        // Push all the elements to the Vector
        for(int i = 0; i < size; ++i)
            push_back(element);
    }
 
    template<class Type> Vector<Type>::Vector(const Vector<Type>& other)
            : m_size(other.m_size),
            m_capacity(other.m_capacity) {
        // Copy each element into a new array
        m_elements = new Type[m_capacity];
        for(uint32_t i = 0; i < m_size; ++i)
            m_elements[i] = other.m_elements[i];
    }
 
    template<class Type> Vector<Type>::Vector(Vector<Type>&& other)
            : m_elements(other.m_elements),
            m_size(other.m_size),
            m_capacity(other.m_capacity) {
 
        // Clear the other Vector
        other.m_elements = nullptr;
        other.m_size = 0;
        other.m_capacity = 0;
 
    }
 
    template<class Type> Vector<Type>::~Vector() {
 
        // De-allocate the array
        delete[] m_elements;
 
    }
 
    template<class Type> void Vector<Type>::increase_size() {
        reserve(m_capacity * 2);
    }
 
    template<class Type> void Vector<Type>::reserve(size_t amount) {
 
 
        // Increase the capacity of the Vector
        if(m_capacity < amount)
            m_capacity = amount;
 
        // Allocate more space for the array
        Type* new_elements = new Type[amount];
 
        // Copy the elements to the new array
        for(uint32_t i = 0; i < m_size; ++i)
            new_elements[i] = m_elements[i];
 
        // De-allocate the old array
        delete[] m_elements;
 
        // Set the new array
        m_elements = new_elements;
    }
 
 
    template<class Type> Type& Vector<Type>::operator [](uint32_t index) const {
 
        // If the index is in the Vector
        if(index < m_size)
            return m_elements[index];
 
        // Return the last element of the Vector
        return m_elements[m_size - 1];
 
    }
 
    template<class Type> Vector<Type>& Vector<Type>::operator =(const Vector<Type>& other) {
 
        // Setting to itself?
        if(this == &other)
            return *this;
 
        // Create a new buffer to store the elements
        delete[] m_elements;
        m_elements = new Type[other.m_capacity];
 
        // Copy data
        m_size = other.m_size;
        m_capacity = other.m_capacity;
        for(uint32_t i = 0; i < m_size; ++i)
            m_elements[i] = other.m_elements[i];
 
        return *this;
    }
 
    template<class Type> Vector<Type>& Vector<Type>::operator =(Vector<Type>&& other) {
 
        // Moving to itself?
        if(this == &other)
            return *this;
 
        // Move into this vector
        delete[] m_elements;
        m_elements = other.m_elements;
        m_size = other.m_size;
        m_capacity = other.m_capacity;
 
        // Remove from other vector
        other.m_elements = nullptr;
        other.m_size = 0;
        other.m_capacity = 0;
 
        return *this;
    }
 
    template<class Type> uint32_t Vector<Type>::size() const {
        return m_size;
    }
 
    template<class Type> typename Vector<Type>::iterator Vector<Type>::begin() const {
        return &m_elements[0];
    }
 
    template<class Type> typename Vector<Type>::iterator Vector<Type>::end() const {
        return &m_elements[0] + m_size;
    }
 
    template<class Type> typename Vector<Type>::iterator Vector<Type>::find(Type element) const {
 
        // Find the element
        for(iterator i = begin(); i != end(); ++i)
            if(*i == element)
                return i;
 
        // The element must not be in the Vector
        return end();
    }
 
    template<class Type> bool Vector<Type>::empty() const {
        return begin() == end();
    }
 
 
    template<class Type> typename Vector<Type>::iterator Vector<Type>::push_back(Type element) {
 
        // Check if we need to allocate more space for the array
        if(m_size == m_capacity)
            increase_size();
 
        // Add the element to the Vector and return the iterator of the element
        m_elements[m_size++] = element;
        return end() - 1;
    }
 
    template<class Type> Type Vector<Type>::pop_back() {
 
        // Remove the last element from the Vector
        if(m_size > 0)
            --m_size;
 
        return m_elements[m_size];
    }
 
    template<class Type> typename Vector<Type>::iterator Vector<Type>::push_front(Type element) {
 
        // Check if we need to allocate more space for the array
        if(m_size == m_capacity)
            increase_size();
 
        // Move all elements one index to the right
        for(iterator i = end(); i > begin(); --i)
            *i = *(i - 1);
 
        // Add the element to the front of the Vector
        m_elements[0] = element;
        ++m_size;
 
        // Return the iterator of the element
        return begin();
    }
 
    template<class Type> Type Vector<Type>::pop_front() {
 
        // Make sure the Vector is not empty
        if(m_size == 0)
            return Type();
 
        // Store the element to return
 
        Type element = m_elements[0];
 
        // Move all elements one index to the left
        for(uint32_t i = 0; i < m_size - 1; ++i)
            m_elements[i] = m_elements[i + 1];
 
        // Decrease the size of the Vector
        --m_size;
        return element;
    }
 
    template<class Type> void Vector<Type>::erase(Type element) {
 
        // Search for the element
        int hits = 0;
        for(iterator i = begin(); i != end(); ++i) {
            // If it is the element we are looking for
            if(*i == element) {
                ++hits;
            } else {
 
                // If there are hits move the element to the left
                if(hits > 0)
                    *(i - hits) = *i;
            }
 
        }
 
        // Decrease the size of the Vector
        m_size -= hits;
    }
 
    template<class Type> void Vector<Type>::erase(typename Vector<Type>::iterator position) {
 
        // If the m_position is not in the Vector
        if(position < begin() || position >= end())
            return;
 
        // Move all elements one index to the left
        for(++position; position != end(); ++position)
            *(position - 1) = *position;
 
        // Decrease the size of the Vector
        --m_size;
    }
 
    template<class Type> void Vector<Type>::clear() {
        m_size = 0;
    }
 
    template<class Type> void Vector<Type>::iterate(VectorIterationHandler<Type>* vector_iteration_handler) {
 
        // Call the OnRead function of the handler for each element
        for(auto& element : m_elements)
            vector_iteration_handler->on_read(element);
 
        // Call the OnEndOfStream function of the handler
        vector_iteration_handler->on_end_of_stream();
    }
 
 
    template<class Type> void Vector<Type>::iterate(void callback(Type&)) {
 
        // Call the callback function for each element
        for(auto& element : m_elements)
            callback(element);
    }
 
    template<class Type> VectorIterationHandler<Type>::VectorIterationHandler() = default;
 
 
 
 
    template<class Type> void VectorIterationHandler<Type>::on_end_of_stream() {
 
    }
 
    template<class Type> void VectorIterationHandler<Type>::on_read(Type) {
 
    }
}
 
 
#endif //MAXOS_COMMON_VECTOR_H