ArrayBase.hpp

#pragma once
 
#include <cstddef>
#include <utility>
 
#include <stratax/core/Buffer.hpp>
#include <stratax/core/Shape.hpp>
#include <stratax/exceptions/Exceptions.hpp>
#include <stratax/indexing/Normalize.hpp>
#include <stratax/core/dtypes/DTypeTraits.hpp>
#include <stratax/core/dtypes/Concepts.hpp>
 
namespace stratax::core {
 
template<DType T>
class ArrayBase
{
public:
    using value_type = typename Buffer<T>::value_type;
    using size_type = typename Buffer<value_type>::size_type;
    using difference_type = typename Buffer<value_type>::difference_type;
    using reference = typename Buffer<value_type>::reference;
    using const_reference = typename Buffer<value_type>::const_reference;
    using pointer = typename Buffer<value_type>::pointer;
    using const_pointer = typename Buffer<value_type>::const_pointer;
    using iterator = typename Buffer<value_type>::iterator;
    using const_iterator = typename Buffer<value_type>::const_iterator;
    using reverse_iterator = typename Buffer<value_type>::reverse_iterator;
    using const_reverse_iterator = typename Buffer<value_type>::const_reverse_iterator;
 
    [[nodiscard]] static constexpr std::string_view dtype() noexcept
    {
        return stratax::core::DTypeTraits<value_type>::name;
    }
 
    [[nodiscard]] size_type size() const noexcept {return buffer_.size();}
 
    [[nodiscard]] bool empty() const noexcept {return buffer_.empty();}
 
    [[nodiscard]] size_type rank() const noexcept {return shape_.rank();}
 
    [[nodiscard]] const Shape& shape() const noexcept {return shape_;}
 
    [[nodiscard]] const Shape& strides() const noexcept {return strides_;}
 
    [[nodiscard]] pointer data() noexcept {return buffer_.data();}
    [[nodiscard]] const_pointer data() const noexcept {return buffer_.data();}
 
    reference front() 
    {
        if (empty())
        {
            throw Exceptions::IndexError("Cannot access the front of an empty array.");
        }
 
        return buffer_.front();
    }
    const_reference front() const 
    {
        if (empty())
        {
            throw Exceptions::IndexError("Cannot access the front of an empty array.");
        }
 
        return buffer_.front();
    }
 
    reference back() 
    {
        if (empty())
        {
            throw Exceptions::IndexError("Cannot access the back of an empty array.");
        }
 
        return buffer_.back();
    }
    const_reference back() const 
    {
        if (empty())
        {
            throw Exceptions::IndexError("Cannot access the back of an empty array.");
        }
        
        return buffer_.back();
    }
 
    reference operator[](size_type index) noexcept {return buffer_[index];}
    const_reference operator[](size_type index) const noexcept {return buffer_[index];}
 
    reference at(difference_type index) {return buffer_[indexing::normalize_index(index, size())];}
    const_reference at(difference_type index) const {return buffer_[indexing::normalize_index(index, size())];}
 
    iterator begin() noexcept {return buffer_.begin();}
    const_iterator begin() const noexcept {return buffer_.begin();}
    const_iterator cbegin() const noexcept {return buffer_.cbegin();}
    iterator end() noexcept {return buffer_.end();}
    const_iterator end() const noexcept {return buffer_.end();}
    const_iterator cend() const noexcept {return buffer_.cend();}
    reverse_iterator rbegin() noexcept {return buffer_.rbegin();}
    const_reverse_iterator rbegin() const noexcept {return buffer_.rbegin();}
    const_reverse_iterator crbegin() const noexcept {return buffer_.crbegin();}
    reverse_iterator rend() noexcept {return buffer_.rend();}
    const_reverse_iterator rend() const noexcept {return buffer_.rend();}
    const_reverse_iterator crend() const noexcept {return buffer_.crend();}
 
    void fill(const_reference value) {buffer_.fill(value);}
 
    void swap(ArrayBase& other) noexcept
    {
        buffer_.swap(other.buffer_);
        shape_.swap(other.shape_);
        strides_.swap(other.strides_);
    }
 
protected:
    explicit ArrayBase(const Shape& shape)
        : buffer_(shape.elements()),
          shape_(shape),
          strides_(shape.strides())
    {}
 
    ArrayBase(const Shape& shape, const_reference value)
        : buffer_(shape.elements(), value),
          shape_(shape),
          strides_(shape.strides())
    {}
 
    ArrayBase(const Shape& shape, Buffer<value_type>&& buffer)
        : buffer_(std::move(buffer)),
          shape_(shape),
          strides_(shape.strides())
    {
        if (buffer_.size() != shape_.elements())
        {
            throw Exceptions::ShapeError(
                "Buffer size does not match the shape's element count.");
        }
    }
 
    template<typename IndexContainer>
    size_type normalized_flat_offset(const IndexContainer& raw_indices) const
    {
        if (raw_indices.size() != rank())
        {
            throw Exceptions::RankError(
                "The number of indices must match the array rank.");
        }
 
        size_type offset = 0;
 
        for (size_type i = 0; i < rank(); ++i)
        {
            const size_type index = indexing::normalize_index(
                raw_indices[i], shape_[i]);
            offset += index * strides_[i];
        }
 
        return offset;
    }
 
private:
    Buffer<value_type> buffer_;
    Shape shape_;
    Shape strides_;
};
 
}