Array.impl.h

#pragma once
#include <type_traits>
#include <string.h>
#ifndef _WIN32
#include <new>
#else
#include <new>
#endif
 
namespace ToolchefsSTL
{
 
    template<typename T>
    Array<T>::Array(Allocator* allocator) noexcept:
        m_data(nullptr),
        m_allocator(allocator),
        m_length(0),
        m_capacity(0)
    {
        
    }
 
    template<typename T>
    Array<T>::Array(size_t num_elements, Allocator* allocator) noexcept:
        m_data(nullptr),
        m_allocator(allocator),
        m_length(num_elements),
        m_capacity(num_elements)
    {
        m_data = static_cast<Array::ptr_type>(m_allocator->malloc(sizeof(T) * m_capacity));
        for (size_t i = 0; i < m_capacity; ++i)
        {
            new (m_data + i) T;
        }
    }
 
    template<typename T>
    Array<T>::Array(size_t num_elements, const T& init_value, Allocator* allocator) noexcept:
        m_data(nullptr),
        m_allocator(allocator),
        m_length(num_elements),
        m_capacity(num_elements)
    {
        m_data = static_cast<Array::ptr_type>(m_allocator->malloc(sizeof(T) * m_capacity));
        for (size_t i = 0; i < m_capacity; ++i)
        {
            new (m_data + i) T(init_value);
        }
    }
 
    template<typename T>
    Array<T>::~Array() noexcept
    {
        clear();
    }
 
    template<typename T>
    Array<T>::Array(const Array& rhs) noexcept:
        m_data(nullptr),
        m_allocator(rhs.m_allocator),
        m_length(rhs.m_length),
        m_capacity(rhs.m_length)
    {
        if (m_length == 0) return;
        m_data = static_cast<Array::ptr_type>(m_allocator->malloc(sizeof(T) * m_capacity));
#if __cplusplus >= 201703L
        if(std::is_trivially_copyable_v<T>)
        {
            memcpy(m_data, rhs.m_data, sizeof(T) * m_length);
        }
        else
#endif
        {
            for (size_t i = 0; i < m_length; ++i)
            {
                new (m_data + i) T(rhs.m_data[i]);
            }
        }
    }
 
    template<typename T>
    Array<T>& Array<T>::operator=(const Array<T>& rhs) noexcept
    {
        if (this == &rhs) return *this;
        if (rhs.m_length == 0)
        {
            clear();
            return *this;
        }
 
        resize(rhs.m_length);
#if __cplusplus >= 201703L
        if (std::is_trivially_copyable_v<T>)
        {
            memcpy(m_data, rhs.m_data, sizeof(T) * m_length);
        }
        else
#endif
        {
            for (size_t i = 0; i < m_length; ++i)
            {;
                m_data[i] = rhs.m_data[i];
            }
        }
        return *this;
    }
 
    template<typename T>
    Array<T>::Array(Array<T>&& rhs) noexcept:
        m_data(rhs.m_data),
        m_allocator(rhs.m_allocator),
        m_length(rhs.m_length),
        m_capacity(rhs.m_capacity)
    {
        rhs.m_length = 0;
        rhs.m_capacity = 0;
        rhs.m_data = nullptr;
    }
    
    template<typename T>
    Array<T>& Array<T>::operator=(Array<T>&& rhs) noexcept
    {
        if (m_data) clear();
        m_data = rhs.m_data;
        m_allocator = rhs.m_allocator;
        m_length = rhs.m_length;
        m_capacity = rhs.m_capacity;
 
        rhs.m_data = nullptr;
        rhs.m_length = 0;
        rhs.m_capacity = 0;
        return *this;
    }
    
    template<typename T>
    bool Array<T>::operator==(const Array& rhs) const noexcept
    {
        if (rhs.m_length != m_length) return false;
        for (size_t i=0; i < m_length; ++i)
        {
            if (m_data[i] != m_data[i]) return false;
        }
        return true;
    }
 
    template<typename T>
    void Array<T>::push_back(const T& element) noexcept
    {
        if (m_capacity == m_length) grow();
        new (m_data + m_length++) T(element);
    }
 
 
 
#if __cplusplus >= 201703L
    template<typename T>
    constexpr T& Array<T>::operator[](const size_t index) noexcept
    {
        assert(index >= 0 && index < m_length);
        return m_data[index];
    }
 
    template<typename T>
    constexpr const T& Array<T>::operator[](const size_t index) const noexcept
    {
        assert(index >= 0 && index < m_length);
        return m_data[index];
    }
#endif
 
    template<typename T>
    typename Array<T>::iterator Array<T>::begin() noexcept
    {
        return m_data;
    }
 
    template<typename T>
    typename Array<T>::iterator Array<T>::end() noexcept
    {
        return &m_data[m_length];
    }
 
    template<typename T>
    typename Array<T>::const_iterator Array<T>::cbegin() const noexcept
    {
        return m_data;
    }
 
    template<typename T>
    typename Array<T>::const_iterator Array<T>::cend() const noexcept
    {
        return &m_data[m_length];
    }
 
    template<typename T>
    typename Array<T>::reverse_iterator Array<T>::rbegin() noexcept
    {
        return reverse_iterator(&back());
    }
 
    template<typename T>
    typename Array<T>::reverse_iterator Array<T>::rend() noexcept
    {
        T* front_ptr = &front();
        return reverse_iterator(--front_ptr);
    }
 
    template<typename T>
    typename Array<T>::const_reverse_iterator Array<T>::crbegin() const noexcept
    {
        return const_reverse_iterator(&back());
    }
 
    template<typename T>
    typename Array<T>::const_reverse_iterator Array<T>::crend() const noexcept
    {
        T* front_ptr = const_cast<T*>(&front());
        return const_reverse_iterator(--front_ptr);
    }
 
    template<typename T>
    T& Array<T>::back() noexcept
    {
        return  m_data[m_length - 1];
    }
 
    template<typename T>
    const T& Array<T>::back() const noexcept
    {
        return m_data[m_length - 1];
    }
 
    template<typename T>
    T& Array<T>::front() noexcept
    {
        return m_data[0];
    }
 
    template<typename T>
    const T& Array<T>::front() const noexcept
    {
        return m_data[0];
    }
 
    template<typename T>
    const T* Array<T>::data() const noexcept
    {
        return m_data;
    }
 
    template<typename T>
    void Array<T>::resize(size_t new_length) noexcept
    {
        if (new_length == m_length) return;
        if (new_length == 0)
        {
            clear();
            return;
        }
        if (new_length > m_length)
        {
            reserve(new_length);
            for (size_t i = m_length; i < new_length; ++i)
            {
                new (m_data + i) T();
            }
            m_length = new_length;
        }
        else
        {
            m_capacity = new_length;
            ptr_type new_buffer = static_cast<ptr_type>(m_allocator->malloc(sizeof(T) * new_length));
#if __cplusplus >= 201703L
            if (std::is_trivially_copyable_v<T>)
            {
                memcpy(new_buffer, m_data, sizeof(T) * new_length);
            }
            else
#endif
            {
                for (size_t i = 0; i < m_length; ++i)
                {
                    T& item = m_data[i];
                    if (i < new_length)
                        new (new_buffer + i) T(std::move(item));
                    item.~T();
                }
            }
            m_allocator->free(m_data);
            m_data = new_buffer;
            m_length = new_length;
        }
    }
 
    template<typename T>
    void Array<T>::clear() noexcept
    {
        if (!std::is_trivially_destructible<T>::value)
        {
            for (size_t i = 0; i < m_length; ++i)
            {
                m_data[i].~T();
            }
        }
 
        if (m_data)
        {
            m_allocator->free(m_data);
            m_data = nullptr;
        }
 
        m_length = 0;
        m_capacity = 0;
    }
 
    template<typename T>
    void Array<T>::reserve(size_t new_capacity) noexcept
    {
        if (new_capacity <= m_capacity) return;
        m_capacity = new_capacity;
        ptr_type new_buffer = static_cast<ptr_type>(m_allocator->malloc(sizeof(T) * m_capacity));
#if __cplusplus >= 201703L
        if (std::is_trivially_copyable_v<T>)
        {
            memcpy(new_buffer, m_data, sizeof(T) * m_length);
        }
        else
#endif
        {
            for (size_t i = 0; i < m_length; ++i)
            {
                T& item = m_data[i];
                new (new_buffer + i) T(std::move(item));
                item.~T();
            }
        }
 
        m_allocator->free(m_data);
        m_data = new_buffer;
    }
 
    template<typename T>
    size_t Array<T>::size() const noexcept
    {
        return m_length;
    }
 
    template<typename T>
    size_t Array<T>::length() const noexcept
    {
        return m_length;
    }
 
    template<typename T>
    size_t Array<T>::capacity() const noexcept
    {
        return m_capacity;
    }
 
    template<typename T>
    void Array<T>::grow() noexcept
    {
        m_capacity = m_capacity == 0 ? 1 : m_capacity << 1;
        ptr_type new_buffer = static_cast<ptr_type>(m_allocator->malloc(sizeof(T) * m_capacity));
#if __cplusplus >= 201703L
        if (std::is_trivially_copyable_v<T>)
        {
            memcpy(new_buffer, m_data, sizeof(T) * m_length);
        }
        else
#endif
        {
            for (size_t i=0; i < m_length; ++i)
            {
                T& item = m_data[i];
                new (new_buffer + i) T(std::move(item));
                item.~T();
            }
        }
 
        m_allocator->free(m_data);
        m_data = new_buffer;
 
    }
 
    template<typename T>
    void Array<T>::pop_back() noexcept
    {
        if (m_length == 0) return;
        m_data[--m_length].~T();
        if (m_length == 0) clear();
    }
 
    template<typename T>
    void Array<T>::insert(size_t index, const T& value) noexcept
    {
        if (index >= m_length) return;
        resize(m_length + 1);
        for (size_t i = (m_length-1); i > index; --i)
            m_data[i] = std::move(m_data[i-1]);
        m_data[index] = value;
    }
 
    template<typename T>
    void Array<T>::insert(iterator it, const T& value) noexcept
    {
        insert(it - m_data, value);
    }
 
    template<typename T>
    void Array<T>::erase(size_t index) noexcept
    {
        if (index >= m_length) return;
        for (size_t i = (index + 1); i < m_length; ++i)
            m_data[i-1] = std::move(m_data[i]);
        m_length--;
        m_data[m_length].~T();
    }
 
    template<typename T>
    typename Array<T>::iterator Array<T>::erase(iterator it) noexcept
    {
        size_t index = it - m_data;
        erase(index);
        return begin() + index;
    }
 
    template<typename T>
    void Array<T>::shrink_to_fit() noexcept
    {
        m_capacity = m_length;
        ptr_type new_buffer = static_cast<ptr_type>(m_allocator->malloc(sizeof(T) * m_capacity));
#if __cplusplus >= 201703L
        if (std::is_trivially_copyable_v<T>)
        {
            memcpy(new_buffer, m_data, sizeof(T) * m_length);
        }
        else
#endif
        {
            for (size_t i = 0; i < m_capacity; ++i)
            {
                T& item = m_data[i];
                new (new_buffer + i) T(std::move(item));
                item.~T();
            }
        }
 
        m_allocator->free(m_data);
        m_data = new_buffer;
    }
 
    template<typename T>
    typename Array<T>::iterator Array<T>::find(const T& element) noexcept
    {
        auto end_it = end();
        for (auto it=begin(); it != end_it; ++it)
        {
            if (*it == element) return it;
        }
        return end();
    }
 
    template<typename T>
    typename Array<T>::const_iterator Array<T>::find(const T& element) const noexcept
    {
        auto end_it = cend();
        for (auto it = cbegin(); it != end_it; ++it)
        {
            if (*it == element) return it;
        }
        return cend();
    }
 
    template<typename T>
    bool Array<T>::empty() const noexcept
    {
        return m_length == 0;
    }
}