Vector.hpp

#pragma once
 
#include <cstddef>
#include <initializer_list>
#include <iterator>
 
#include <stratax/core/containers/Buffer.hpp>
#include <stratax/core/Concepts.hpp>
#include <stratax/core/containers/Shape.hpp>
#include <stratax/core/containers/Strides.hpp>
#include <stratax/core/Exceptions.hpp>
#include <stratax/core/validation/Validation.hpp>
 
namespace stratax::container {

template<typename T>
requires Numeric<T>
class Vector
{
private:
    core::Shape shape_;
    core::Strides strides_;
    core::Buffer<T> buffer_;
 
public:
    using value_type = T;

    using iterator = typename core::Buffer<T>::iterator;

    using const_iterator = typename core::Buffer<T>::const_iterator;

    using reverse_iterator = typename core::Buffer<T>::reverse_iterator;

    using const_reverse_iterator = typename core::Buffer<T>::const_reverse_iterator;

    template<typename U>
    using rebind = Vector<U>;

    Vector() noexcept = default;

    explicit Vector(std::size_t size)
        : shape_({size}, core::Shape::allow_zero),
          strides_(shape_),
          buffer_(size)
    {
    }

    explicit Vector(const core::Shape& shape)
        : shape_(core::validation::require_rank(shape, 1, "Shape must be rank 1")),
          strides_(shape_),
          buffer_(shape_.elements())
    {
    }

    Vector(std::size_t size, const T& value)
        : shape_({size}, core::Shape::allow_zero),
          strides_(shape_),
          buffer_(size, value)
    {
    }

    Vector(std::initializer_list<T> list)
        : shape_({list.size()}, core::Shape::allow_zero),
          strides_(shape_),
          buffer_(list)
    {
    }
 
    // Rule of Five

    Vector(const Vector&) = default;

    Vector(Vector&&) noexcept = default;

    Vector& operator=(const Vector&) = default;

    Vector& operator=(Vector&&) noexcept = default;

    ~Vector() = default;

    T& operator()(std::size_t index) noexcept
    {
            return buffer_[index];
    }

    const T& operator()(std::size_t index) const noexcept
    {
            return buffer_[index];
    }

    T& operator[](std::size_t index) noexcept
    {
        return buffer_[index];
    }

    const T& operator[](std::size_t index) const noexcept
    {
        return buffer_[index];
    }

    T& at(std::ptrdiff_t index)
    {
        const std::size_t normalized =
            core::validation::normalize_index(index, size(), "Vector index out of bounds.");
        return buffer_[normalized];
    }

    const T& at(std::ptrdiff_t index) const
    {
        const std::size_t normalized =
            core::validation::normalize_index(index, size(), "Vector index out of bounds.");
        return buffer_[normalized];
    }

    T& front()
    {
        return buffer_.front();
    }

    const T& front() const
    {
        return buffer_.front();
    }

    T& back()
    {
        return buffer_.back();
    }

    const T& back() const
    {
        return buffer_.back();
    }

    [[nodiscard]] std::size_t size() const noexcept
    {
    return shape_.elements();
    }

    [[nodiscard]] std::size_t rank() const noexcept
    {
        return shape_.rank();
    }

    [[nodiscard]] bool empty() const noexcept
    {
    return buffer_.empty();
    }

    const stratax::core::Shape& shape() const noexcept
    {
    return shape_;
    }

    const stratax::core::Strides& strides() const noexcept
    {
        return strides_;
    }

    [[nodiscard]] T* data() noexcept
    {
    return buffer_.data();
    }

    [[nodiscard]] const T* data() const noexcept
    {
    return buffer_.data();
    }

    [[nodiscard]] iterator begin() noexcept
    {
        return buffer_.begin();
    }

    [[nodiscard]] const_iterator begin() const noexcept
    {
        return buffer_.begin();
    }

    [[nodiscard]] const_iterator cbegin() const noexcept
    {
        return buffer_.cbegin();
    }

    [[nodiscard]] iterator end() noexcept
    {
        return buffer_.end();
    }

    [[nodiscard]] const_iterator end() const noexcept
    {
        return buffer_.end();
    }

    [[nodiscard]] const_iterator cend() const noexcept
    {
        return buffer_.cend();
    }

    [[nodiscard]] reverse_iterator rbegin() noexcept
    {
        return buffer_.rbegin();
    }

    [[nodiscard]] const_reverse_iterator rbegin() const noexcept
    {
        return buffer_.rbegin();
    }

    [[nodiscard]] const_reverse_iterator crbegin() const noexcept
    {
        return buffer_.crbegin();
    }

    [[nodiscard]] reverse_iterator rend() noexcept
    {
        return buffer_.rend();
    }

    [[nodiscard]] const_reverse_iterator rend() const noexcept
    {
        return buffer_.rend();
    }

    [[nodiscard]] const_reverse_iterator crend() const noexcept
    {
        return buffer_.crend();
    }

    void fill(const T& value)
    {
        buffer_.fill(value);
    }

    void swap(Vector& other) noexcept
    {
        using std::swap;
 
        swap(shape_, other.shape_);
        swap(strides_, other.strides_);
        swap(buffer_, other.buffer_);
    }
 
};
 
}