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() {return buffer_.front();}
    const_reference front() const {return buffer_.front();}

    reference back() {return buffer_.back();}
    const_reference back() const {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 must match shape element count.");
        }
    }

    template<typename IndexContainer>
    size_type normalized_flat_offset(
        const IndexContainer& raw_indices,
        const char* rank_mismatch_message = "Multi-index rank must match array rank.",
        const char* component_oob_message = nullptr
    ) const
    {
        if (raw_indices.size() != rank())
        {
            throw Exceptions::IndexError(rank_mismatch_message);
        }
 
        size_type offset = 0;
 
        for (size_type i = 0; i < rank(); ++i)
        {
            try
            {
                const size_type index =
                    indexing::normalize_index(
                        raw_indices[i],
                        shape_[i]);
 
                offset += index * strides_[i];
            }
            catch (const Exceptions::IndexError&)
            {
                if (component_oob_message != nullptr)
                {
                    throw Exceptions::IndexError(component_oob_message);
                }
 
                throw;
            }
        }
 
        return offset;
    }
 
private:
    Buffer<value_type> buffer_;
    Shape shape_;
    Shape strides_;
};
 
}