Merge pull request #226 from JohanMabille/array_reference

Moved pyarray_backstrides to a dedicated file

Author: JohanMabille

CMakeLists.txt

@@ -46,6 +46,7 @@ message(STATUS "Found numpy: ${NUMPY_INCLUDE_DIRS}")
 
 set(XTENSOR_PYTHON_HEADERS
     ${XTENSOR_PYTHON_INCLUDE_DIR}/xtensor-python/pyarray.hpp
+    ${XTENSOR_PYTHON_INCLUDE_DIR}/xtensor-python/pyarray_backstrides.hpp
     ${XTENSOR_PYTHON_INCLUDE_DIR}/xtensor-python/pycontainer.hpp
     ${XTENSOR_PYTHON_INCLUDE_DIR}/xtensor-python/pystrides_adaptor.hpp
     ${XTENSOR_PYTHON_INCLUDE_DIR}/xtensor-python/pytensor.hpp

include/xtensor-python/pyarray.hpp

@@ -18,6 +18,7 @@
 #include "xtensor/xiterator.hpp"
 #include "xtensor/xsemantic.hpp"
 
+#include "pyarray_backstrides.hpp"
 #include "pycontainer.hpp"
 #include "pystrides_adaptor.hpp"
 #include "xtensor_type_caster_base.hpp"
@@ -100,200 +101,6 @@ namespace pybind11
 
 namespace xt
 {
-
-    /**************************
-     * pybackstrides_iterator *
-     **************************/
-
-    template <class B>
-    class pybackstrides_iterator
-    {
-    public:
-
-        using self_type = pybackstrides_iterator<B>;
-
-        using value_type = typename B::value_type;
-        using pointer = const value_type*;
-        using reference = value_type;
-        using difference_type = std::ptrdiff_t;
-        using iterator_category = std::random_access_iterator_tag;
-
-        inline pybackstrides_iterator(const B* b, std::size_t offset)
-            : p_b(b), m_offset(offset)
-        {
-        }
-
-        inline reference operator*() const
-        {
-            return p_b->operator[](m_offset);
-        }
-
-        inline pointer operator->() const
-        {
-            // Returning the address of a temporary
-            value_type res = p_b->operator[](m_offset);
-            return &res;
-        }
-
-        inline reference operator[](difference_type n) const
-        {
-            return p_b->operator[](m_offset + n);
-        }
-
-        inline self_type& operator++()
-        {
-            ++m_offset;
-            return *this;
-        }
-
-        inline self_type& operator--()
-        {
-            --m_offset;
-            return *this;
-        }
-
-        inline self_type operator++(int)
-        {
-            self_type tmp(*this);
-            ++m_offset;
-            return tmp;
-        }
-
-        inline self_type operator--(int)
-        {
-            self_type tmp(*this);
-            --m_offset;
-            return tmp;
-        }
-
-        inline self_type& operator+=(difference_type n)
-        {
-            m_offset += n;
-            return *this;
-        }
-
-        inline self_type& operator-=(difference_type n)
-        {
-            m_offset -= n;
-            return *this;
-        }
-
-        inline self_type operator+(difference_type n) const
-        {
-            return self_type(p_b, m_offset + n);
-        }
-
-        inline self_type operator-(difference_type n) const
-        {
-            return self_type(p_b, m_offset - n);
-        }
-
-        inline self_type operator-(const self_type& rhs) const
-        {
-            self_type tmp(*this);
-            tmp -= (m_offset - rhs.m_offset);
-            return tmp;
-        }
-
-        inline std::size_t offset() const
-        {
-            return m_offset;
-        }
-
-    private:
-
-        const B* p_b;
-        std::size_t m_offset;
-    };
-
-    template <class B>
-    inline bool operator==(const pybackstrides_iterator<B>& lhs,
-                           const pybackstrides_iterator<B>& rhs)
-    {
-        return lhs.offset() == rhs.offset();
-    }
-
-    template <class B>
-    inline bool operator!=(const pybackstrides_iterator<B>& lhs,
-                           const pybackstrides_iterator<B>& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-    template <class B>
-    inline bool operator<(const pybackstrides_iterator<B>& lhs,
-                          const pybackstrides_iterator<B>& rhs)
-    {
-        return lhs.offset() < rhs.offset();
-    }
-
-    template <class B>
-    inline bool operator<=(const pybackstrides_iterator<B>& lhs,
-                           const pybackstrides_iterator<B>& rhs)
-    {
-        return (lhs < rhs) || (lhs == rhs);
-    }
-
-    template <class B>
-    inline bool operator>(const pybackstrides_iterator<B>& lhs,
-                          const pybackstrides_iterator<B>& rhs)
-    {
-        return !(lhs <= rhs);
-    }
-
-    template <class B>
-    inline bool operator>=(const pybackstrides_iterator<B>& lhs,
-                           const pybackstrides_iterator<B>& rhs)
-    {
-        return !(lhs < rhs);
-    }
-
-    template <class A>
-    class pyarray_backstrides
-    {
-    public:
-
-        using self_type = pyarray_backstrides<A>;
-        using array_type = A;
-        using value_type = typename array_type::size_type;
-        using const_reference = value_type;
-        using reference = const_reference;
-        using const_pointer = const value_type*;
-        using pointer = const_pointer;
-        using size_type = typename array_type::size_type;
-        using difference_type = typename array_type::difference_type;
-
-        using const_iterator = pybackstrides_iterator<self_type>;
-        using iterator = const_iterator;
-        using reverse_iterator = std::reverse_iterator<iterator>;
-        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-        pyarray_backstrides() = default;
-        pyarray_backstrides(const array_type& a);
-
-        bool empty() const;
-        size_type size() const;
-
-        value_type operator[](size_type i) const;
-
-        const_reference front() const;
-        const_reference back() const;
-
-        const_iterator begin() const;
-        const_iterator end() const;
-        const_iterator cbegin() const;
-        const_iterator cend() const;
-
-        const_reverse_iterator rbegin() const;
-        const_reverse_iterator rend() const;
-        const_reverse_iterator crbegin() const;
-        const_reverse_iterator crend() const;
-
-    private:
-
-        const array_type* p_a;
-    };
-
     template <class T, layout_type L>
     struct xiterable_inner_types<pyarray<T, L>>
         : xcontainer_iterable_types<pyarray<T, L>>
@@ -425,101 +232,6 @@ namespace xt
         friend class pycontainer<pyarray<T, L>>;
     };
 
-    /**************************************
-     * pyarray_backstrides implementation *
-     **************************************/
-
-    template <class A>
-    inline pyarray_backstrides<A>::pyarray_backstrides(const array_type& a)
-        : p_a(&a)
-    {
-    }
-
-    template <class A>
-    inline bool pyarray_backstrides<A>::empty() const
-    {
-        return p_a->dimension() == 0;
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::size() const -> size_type
-    {
-        return p_a->dimension();
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::operator[](size_type i) const -> value_type
-    {
-        value_type sh = p_a->shape()[i];
-        value_type res = sh == 1 ? 0 : (sh - 1) * p_a->strides()[i];
-        return res;
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::front() const -> const_reference
-    {
-        value_type sh = p_a->shape()[0];
-        value_type res = sh == 1 ? 0 : (sh - 1) * p_a->strides()[0];
-        return res;
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::back() const -> const_reference
-    {
-        auto index = p_a->size() - 1;
-        value_type sh = p_a->shape()[index];
-        value_type res = sh == 1 ? 0 : (sh - 1) * p_a->strides()[index];
-        return res;
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::begin() const -> const_iterator
-    {
-        return cbegin();
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::end() const -> const_iterator
-    {
-        return cend();
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::cbegin() const -> const_iterator
-    {
-        return const_iterator(this, 0);
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::cend() const -> const_iterator
-    {
-        return const_iterator(this, size());
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::rbegin() const -> const_reverse_iterator
-    {
-        return crbegin();
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::rend() const -> const_reverse_iterator
-    {
-        return crend();
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::crbegin() const -> const_reverse_iterator
-    {
-        return const_reverse_iterator(end());
-    }
-
-    template <class A>
-    inline auto pyarray_backstrides<A>::crend() const -> const_reverse_iterator
-    {
-        return const_reverse_iterator(begin());
-    }
-
     /**************************
      * pyarray implementation *
      **************************/