fields.h

#ifndef ARRAY_HELPER_H
#define ARRAY_HELPER_H
 
#include <cstddef>
#include <iterator>
#include <type_traits>
 
namespace fields {
 
template <class T>
class Helper {
  public:
    Helper(T* array, const int n[3], const int pad[6]);
 
    T& at(int i, int j, int k) const;
 
    std::size_t size() const;
 
    Helper<T> slice(int is, int ie, int js, int je, int ks, int ke) const;
 
    struct Iterator {
        using iterator_category = std::forward_iterator_tag;
        using value_type = T;
        using difference_type = long;
        using pointer = T*;
        using reference = T&;
        Iterator() = default;
 
        Iterator(Helper<T> array, int i, int j, int k);
 
        T& operator*() const
        {
            return *ptr;
        }
 
        T* operator->()
        {
            return ptr;
        }
 
        const T* operator->() const
        {
            return ptr;
        }
 
        bool operator==(const Iterator& other) const
        {
            return ptr == other.ptr;
        }
 
        bool operator!=(const Iterator& other) const
        {
            return ptr != other.ptr;
        }
 
      protected:
        T* ptr;
        int index[2];
        int n[2];
        int jump[2];
    };
 
    struct forward_Iterator : public Iterator {
        forward_Iterator(Helper<T> array, int i, int j, int k) : Iterator(array, i, j, k){};
 
        forward_Iterator& operator++();
 
        forward_Iterator operator++(int)
        {
            forward_Iterator tmp = *this;
            ++(*this);
            return tmp;
        }
    };
 
    struct reverse_Iterator : public Iterator {
        reverse_Iterator(Helper<T> array, int i, int j, int k) : Iterator(array, i, j, k){};
 
        reverse_Iterator& operator++();
 
        reverse_Iterator operator++(int)
        {
            reverse_Iterator tmp = *this;
            ++(*this);
            return tmp;
        }
    };
 
    forward_Iterator begin() const
    {
        return _begin;
    }
 
    forward_Iterator end() const
    {
        return _end;
    }
 
    reverse_Iterator rbegin() const
    {
        return _rbegin;
    }
 
    reverse_Iterator rend() const
    {
        return _rend;
    }
 
  protected:
    T* const basePtr;
    int const n[3];
 
    int const pad[6];
 
  private:
    constexpr std::ptrdiff_t getIndex(int i, int j, int k) const;
 
    const forward_Iterator _begin = forward_Iterator(*this, 0, 0, 0);
    const forward_Iterator _end = ++forward_Iterator(*this, n[0] - 1, n[1] - 1, n[2] - 1);
 
    const reverse_Iterator _rend = ++reverse_Iterator(*this, 0, 0, 0);
    const reverse_Iterator _rbegin = reverse_Iterator(*this, n[0] - 1, n[1] - 1, n[2] - 1);
};
 
template <class T>
class Owner : public Helper<T> {
  public:
    Owner(const int n[3], const int pad[6]);
 
    Owner(T* array, const int n[3], const int pad[6]) = delete;
 
    Owner(const Owner<T>& rhs);
 
    ~Owner();
};
 
constexpr std::size_t getLength(const int n[3], const int pad[6])
{
    return (n[0] + pad[0] + pad[1]) * (n[1] + pad[2] + pad[3]) * (n[2] + pad[4] + pad[5]);
}
 
template <class T>
inline Helper<T>::Helper(T* array, const int n[3], const int pad[6])
    : basePtr{array}, n{n[0], n[1], n[2]}, pad{pad[0], pad[1], pad[2], pad[3], pad[4], pad[5]}
{
}
 
template <class T>
inline T& Helper<T>::at(int i, int j, int k) const
{
    return *(basePtr + getIndex(i, j, k));
}
 
template <class T>
inline std::size_t Helper<T>::size() const
{
    return n[0] * n[1] * n[2];
}
 
template <class T>
inline Helper<T> Helper<T>::slice(int is, int ie, int js, int je, int ks, int ke) const
{
    int n_new[3] = {ie - is, je - js, ke - ks};
    int pad_new[6] = {
        pad[0] + is,          pad[1] + (n[0] - ie), pad[2] + js,
        pad[3] + (n[1] - je), pad[4] + ks,          pad[5] + (n[2] - ke),
    };
 
    return Helper<T>(basePtr, n_new, pad_new);
}
 
template <typename T>
constexpr std::ptrdiff_t Helper<T>::getIndex(int i, int j, int k) const
{
    std::ptrdiff_t bounds[3] = {
        n[0] + pad[0] + pad[1], n[1] + pad[2] + pad[3], n[2] + pad[4] + pad[5]};
 
#ifdef F_STYLE
    return ((k + pad[4]) * bounds[1] + (j + pad[2])) * bounds[0] + i + pad[0];
#else
    return ((i + pad[0]) * bounds[1] + (j + pad[2])) * bounds[2] + k + pad[4];
#endif
}
 
template <class T>
inline Helper<T>::Iterator::Iterator(Helper<T> array, int i, int j, int k)
    :
// clang-format off
#ifdef F_STYLE
    index{i,j},
    n{array.n[0], array.n[1]},
    jump{
        (array.pad[0]+array.pad[1]),
        (array.pad[2]+array.pad[3]) * (array.n[0]+array.pad[0]+array.pad[1])
    }
{
#else
    index{k,j},
    n{array.n[2], array.n[1]},
    jump{
        (array.pad[4]+array.pad[5]),
        (array.pad[2]+array.pad[3]) * (array.n[2]+array.pad[4]+array.pad[5])
    }
{
#endif
    ptr=array.basePtr+array.getIndex(i,j,k);
}
// clang-format on
 
template <class T>
inline typename Helper<T>::forward_Iterator& Helper<T>::forward_Iterator::operator++()
{
    ++Iterator::ptr;
    ++Iterator::index[0];
 
    if (Iterator::index[0] == Iterator::n[0]) {
        Iterator::index[0] = 0;
 
        Iterator::ptr += Iterator::jump[0];
        ++Iterator::index[1];
 
        if (Iterator::index[1] == Iterator::n[1]) {
            Iterator::index[1] = 0;
 
            Iterator::ptr += Iterator::jump[1];
        }
    }
 
    return *this;
}
 
template <class T>
inline typename Helper<T>::reverse_Iterator& Helper<T>::reverse_Iterator::operator++()
{
    if (Iterator::index[0] == 0) {
        Iterator::index[0] = Iterator::n[0];
 
        if (Iterator::index[1] == 0) {
            Iterator::index[1] = Iterator::n[1];
 
            Iterator::ptr -= Iterator::jump[1];
        }
        Iterator::ptr -= Iterator::jump[0];
        --Iterator::index[1];
    }
 
    --Iterator::ptr;
    --Iterator::index[0];
 
    return *this;
}
 
template <class T>
inline Owner<T>::Owner(const int n[3], const int pad[6])
    : Helper<T>(new T[getLength(n, pad)], n, pad)
{
}
 
template <class T>
inline Owner<T>::Owner(const Owner<T>& other)
    : Helper<T>(new T[getLength(other.n, other.pad)], other.n, other.pad)
{
    std::copy(other.basePtr, other.basePtr + getLength(other.n, other.pad), this->basePtr);
}
 
template <class T>
inline Owner<T>::~Owner()
{
    delete[] this->basePtr;
}
 
} // namespace fields
 
#endif