Vector.hpp

#pragma once
 
#include <cstddef>
#include <initializer_list>
 
#include <stratax/core/dtypes/Concepts.hpp>
#include <stratax/core/ArrayBase.hpp>
#include <stratax/core/Buffer.hpp>
#include <stratax/core/Shape.hpp>
#include <stratax/exceptions/Exceptions.hpp>
 
namespace stratax::container {

template<typename T>
requires DType<T>
class Vector : public core::ArrayBase<T>
{
public:
    using value_type = typename core::ArrayBase<T>::value_type;
    using size_type = typename core::ArrayBase<T>::size_type;
    using difference_type = typename core::ArrayBase<T>::difference_type;
    using reference = typename core::ArrayBase<T>::reference;
    using const_reference = typename core::ArrayBase<T>::const_reference;
    using pointer = typename core::ArrayBase<T>::pointer;
    using const_pointer = typename core::ArrayBase<T>::const_pointer;
    using iterator = typename core::ArrayBase<T>::iterator;
    using const_iterator = typename core::ArrayBase<T>::const_iterator;
    using reverse_iterator = typename core::ArrayBase<T>::reverse_iterator;
    using const_reverse_iterator = typename core::ArrayBase<T>::const_reverse_iterator;

    explicit Vector(size_type size)
        : core::ArrayBase<T>(core::Shape{size})
    {}

    explicit Vector(const core::Shape& shape)
        : core::ArrayBase<T>(validate_shape(shape))
    {}

    Vector(size_type size, const_reference value)
        : core::ArrayBase<T>(core::Shape{size}, value)
    {}

    Vector(std::initializer_list<value_type> list)
        : core::ArrayBase<T>(core::Shape{list.size()}, core::Buffer<value_type>(list))
    {}

    Vector() : Vector(0) {}

    void swap(Vector& other) noexcept
    {
        core::ArrayBase<T>::swap(other);
    }

    friend void swap(Vector& lhs, Vector& rhs) noexcept
    {
        lhs.swap(rhs);
    }
 
private:
    static const core::Shape& validate_shape(const core::Shape& shape)
    {
        if (shape.rank() != 1) {
            throw Exceptions::ShapeError(
                "Vector shape must be rank 1.");
        }
 
        return shape;
    }
};
 
} // namespace stratax::container