safe/unsafe access policy

Author: JohanMabille

include/pybind11/numpy.h

@@ -316,7 +316,64 @@ class dtype : public object {
     }
 };
 
-class array : public buffer {
+namespace detail {
+    inline void fail_dim_check(size_t dim, size_t ndim, const std::string& msg) {
+        throw index_error(msg + ": " + std::to_string(dim) +
+                          " (ndim = " + std::to_string(ndim) + ")");
+    }
+}
+
+class safe_access_policy {
+public:
+    void check_axis(size_t dim, size_t ndim) const {
+        if(dim >= ndim) {
+            detail::fail_dim_check(dim, ndim, "invalid axis");
+        }
+    }
+
+    template <typename... Ix>
+    void check_indices(size_t ndim, Ix...) const
+    {
+        if(sizeof...(Ix) > ndim) {
+            detail::fail_dim_check(sizeof...(Ix), ndim, "too many indices for an array");
+        }
+    }
+
+    template<typename... Ix>
+    void check_dimensions(const size_t* shape, Ix... index) const {
+        check_dimensions_impl(size_t(0), shape, size_t(index)...);
+    }
+
+private:
+    void check_dimensions_impl(size_t, const size_t*) const { }
+
+    template<typename... Ix>
+    void check_dimensions_impl(size_t axis, const size_t* shape, size_t i, Ix... index) const {
+        if (i >= *shape) {
+            throw index_error(std::string("index ") + std::to_string(i) +
+                              " is out of bounds for axis " + std::to_string(axis) +
+                              " with size " + std::to_string(*shape));
+        }
+        check_dimensions_impl(axis + 1, shape + 1, index...);
+    }
+};
+
+class unsafe_access_policy {
+public:
+    void check_axis(size_t, size_t) const {
+    }
+
+    template <typename... Ix>
+    void check_indices(size_t, Ix...) const {
+    }
+
+    template <typename... Ix>
+    void check_dimensions(const size_t*, Ix...) const {
+    }
+};
+
+template <class access_policy = safe_access_policy>
+class array : public buffer, private access_policy {
 public:
     PYBIND11_OBJECT_CVT(array, buffer, detail::npy_api::get().PyArray_Check_, raw_array)
 
@@ -424,8 +481,7 @@ class array : public buffer {
 
     /// Dimension along a given axis
     size_t shape(size_t dim) const {
-        if (dim >= ndim())
-            fail_dim_check(dim, "invalid axis");
+        access_policy::check_axis(dim, ndim());
         return shape()[dim];
     }
 
@@ -436,8 +492,7 @@ class array : public buffer {
 
     /// Stride along a given axis
     size_t strides(size_t dim) const {
-        if (dim >= ndim())
-            fail_dim_check(dim, "invalid axis");
+        access_policy::check_axis(dim, ndim());
         return strides()[dim];
     }
 
@@ -473,8 +528,7 @@ class array : public buffer {
     /// Byte offset from beginning of the array to a given index (full or partial).
     /// May throw if the index would lead to out of bounds access.
     template<typename... Ix> size_t offset_at(Ix... index) const {
-        if (sizeof...(index) > ndim())
-            fail_dim_check(sizeof...(index), "too many indices for an array");
+        access_policy::check_indices(ndim(), index...);
         return byte_offset(size_t(index)...);
     }
 
@@ -504,13 +558,8 @@ class array : public buffer {
 protected:
     template<typename, typename> friend struct detail::npy_format_descriptor;
 
-    void fail_dim_check(size_t dim, const std::string& msg) const {
-        throw index_error(msg + ": " + std::to_string(dim) +
-                          " (ndim = " + std::to_string(ndim()) + ")");
-    }
-
     template<typename... Ix> size_t byte_offset(Ix... index) const {
-        check_dimensions(index...);
+        access_policy::check_dimensions(shape(), index...);
         return byte_offset_unsafe(index...);
     }
 
@@ -537,21 +586,6 @@ class array : public buffer {
         return strides;
     }
 
-    template<typename... Ix> void check_dimensions(Ix... index) const {
-        check_dimensions_impl(size_t(0), shape(), size_t(index)...);
-    }
-
-    void check_dimensions_impl(size_t, const size_t*) const { }
-
-    template<typename... Ix> void check_dimensions_impl(size_t axis, const size_t* shape, size_t i, Ix... index) const {
-        if (i >= *shape) {
-            throw index_error(std::string("index ") + std::to_string(i) +
-                              " is out of bounds for axis " + std::to_string(axis) +
-                              " with size " + std::to_string(*shape));
-        }
-        check_dimensions_impl(axis + 1, shape + 1, index...);
-    }
-
     /// Create array from any object -- always returns a new reference
     static PyObject *raw_array(PyObject *ptr, int ExtraFlags = 0) {
         if (ptr == nullptr)
@@ -561,35 +595,36 @@ class array : public buffer {
     }
 };
 
-template <typename T, int ExtraFlags = array::forcecast> class array_t : public array {
+template <typename T, int ExtraFlags = array<>::forcecast> class array_t : public array<> {
 public:
-    array_t() : array(0, static_cast<const T *>(nullptr)) {}
-    array_t(handle h, borrowed_t) : array(h, borrowed) { }
-    array_t(handle h, stolen_t) : array(h, stolen) { }
+    using base_type = array<>;
+    array_t() : base_type(0, static_cast<const T *>(nullptr)) {}
+    array_t(handle h, borrowed_t) : base_type(h, borrowed) { }
+    array_t(handle h, stolen_t) : base_type(h, stolen) { }
 
     PYBIND11_DEPRECATED("Use array_t<T>::ensure() instead")
-    array_t(handle h, bool is_borrowed) : array(raw_array_t(h.ptr()), stolen) {
+    array_t(handle h, bool is_borrowed) : base_type(raw_array_t(h.ptr()), stolen) {
         if (!m_ptr) PyErr_Clear();
         if (!is_borrowed) Py_XDECREF(h.ptr());
     }
 
-    array_t(const object &o) : array(raw_array_t(o.ptr()), stolen) {
+    array_t(const object &o) : base_type(raw_array_t(o.ptr()), stolen) {
         if (!m_ptr) throw error_already_set();
     }
 
-    explicit array_t(const buffer_info& info) : array(info) { }
+    explicit array_t(const buffer_info& info) : base_type(info) { }
 
     array_t(const std::vector<size_t> &shape,
             const std::vector<size_t> &strides, const T *ptr = nullptr,
             handle base = handle())
-        : array(shape, strides, ptr, base) { }
+        : base_type(shape, strides, ptr, base) { }
 
     explicit array_t(const std::vector<size_t> &shape, const T *ptr = nullptr,
             handle base = handle())
-        : array(shape, ptr, base) { }
+        : base_type(shape, ptr, base) { }
 
     explicit array_t(size_t count, const T *ptr = nullptr, handle base = handle())
-        : array(count, ptr, base) { }
+        : base_type(count, ptr, base) { }
 
     constexpr size_t itemsize() const {
         return sizeof(T);
@@ -600,25 +635,25 @@ template <typename T, int ExtraFlags = array::forcecast> class array_t : public
     }
 
     template<typename... Ix> const T* data(Ix... index) const {
-        return static_cast<const T*>(array::data(index...));
+        return static_cast<const T*>(base_type::data(index...));
     }
 
     template<typename... Ix> T* mutable_data(Ix... index) {
-        return static_cast<T*>(array::mutable_data(index...));
+        return static_cast<T*>(base_type::mutable_data(index...));
     }
 
     // Reference to element at a given index
     template<typename... Ix> const T& at(Ix... index) const {
         if (sizeof...(index) != ndim())
-            fail_dim_check(sizeof...(index), "index dimension mismatch");
-        return *(static_cast<const T*>(array::data()) + byte_offset(size_t(index)...) / itemsize());
+            detail::fail_dim_check(sizeof...(index), ndim(), "index dimension mismatch");
+        return *(static_cast<const T*>(base_type::data()) + byte_offset(size_t(index)...) / itemsize());
     }
 
     // Mutable reference to element at a given index
     template<typename... Ix> T& mutable_at(Ix... index) {
         if (sizeof...(index) != ndim())
-            fail_dim_check(sizeof...(index), "index dimension mismatch");
-        return *(static_cast<T*>(array::mutable_data()) + byte_offset(size_t(index)...) / itemsize());
+            detail::fail_dim_check(sizeof...(index), ndim(), "index dimension mismatch");
+        return *(static_cast<T*>(base_type::mutable_data()) + byte_offset(size_t(index)...) / itemsize());
     }
 
     /// Ensure that the argument is a NumPy array of the correct dtype.
@@ -811,7 +846,7 @@ inline PYBIND11_NOINLINE void register_structured_dtype(
 
     // Sanity check: verify that NumPy properly parses our buffer format string
     auto& api = npy_api::get();
-    auto arr =  array(buffer_info(nullptr, itemsize, format_str, 1));
+    auto arr =  array<>(buffer_info(nullptr, itemsize, format_str, 1));
     if (!api.PyArray_EquivTypes_(dtype_ptr, arr.dtype().ptr()))
         pybind11_fail("NumPy: invalid buffer descriptor!");
 
@@ -1076,11 +1111,11 @@ struct vectorize_helper {
     template <typename T>
     explicit vectorize_helper(T&&f) : f(std::forward<T>(f)) { }
 
-    object operator()(array_t<Args, array::c_style | array::forcecast>... args) {
+    object operator()(array_t<Args, array<>::c_style | array<>::forcecast>... args) {
         return run(args..., make_index_sequence<sizeof...(Args)>());
     }
 
-    template <size_t ... Index> object run(array_t<Args, array::c_style | array::forcecast>&... args, index_sequence<Index...> index) {
+    template <size_t ... Index> object run(array_t<Args, array<>::c_style | array<>::forcecast>&... args, index_sequence<Index...> index) {
         /* Request buffers from all parameters */
         const size_t N = sizeof...(Args);