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>(shape)
    {
        if (shape.rank() != 1)
        {
            throw Exceptions::RankError("Vector requires a rank-1 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);
    }
 
};
 
} // namespace stratax::container