| /* |
| pybind11/buffer_info.h: Python buffer object interface |
| |
| Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> |
| |
| All rights reserved. Use of this source code is governed by a |
| BSD-style license that can be found in the LICENSE file. |
| */ |
| |
| #pragma once |
| |
| #include "detail/common.h" |
| |
| PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) |
| |
| PYBIND11_NAMESPACE_BEGIN(detail) |
| |
| // Default, C-style strides |
| inline std::vector<ssize_t> c_strides(const std::vector<ssize_t> &shape, ssize_t itemsize) { |
| auto ndim = shape.size(); |
| std::vector<ssize_t> strides(ndim, itemsize); |
| if (ndim > 0) |
| for (size_t i = ndim - 1; i > 0; --i) |
| strides[i - 1] = strides[i] * shape[i]; |
| return strides; |
| } |
| |
| // F-style strides; default when constructing an array_t with `ExtraFlags & f_style` |
| inline std::vector<ssize_t> f_strides(const std::vector<ssize_t> &shape, ssize_t itemsize) { |
| auto ndim = shape.size(); |
| std::vector<ssize_t> strides(ndim, itemsize); |
| for (size_t i = 1; i < ndim; ++i) |
| strides[i] = strides[i - 1] * shape[i - 1]; |
| return strides; |
| } |
| |
| PYBIND11_NAMESPACE_END(detail) |
| |
| /// Information record describing a Python buffer object |
| struct buffer_info { |
| void *ptr = nullptr; // Pointer to the underlying storage |
| ssize_t itemsize = 0; // Size of individual items in bytes |
| ssize_t size = 0; // Total number of entries |
| std::string format; // For homogeneous buffers, this should be set to format_descriptor<T>::format() |
| ssize_t ndim = 0; // Number of dimensions |
| std::vector<ssize_t> shape; // Shape of the tensor (1 entry per dimension) |
| std::vector<ssize_t> strides; // Number of bytes between adjacent entries (for each per dimension) |
| bool readonly = false; // flag to indicate if the underlying storage may be written to |
| |
| buffer_info() = default; |
| |
| buffer_info(void *ptr, ssize_t itemsize, const std::string &format, ssize_t ndim, |
| detail::any_container<ssize_t> shape_in, detail::any_container<ssize_t> strides_in, bool readonly=false) |
| : ptr(ptr), itemsize(itemsize), size(1), format(format), ndim(ndim), |
| shape(std::move(shape_in)), strides(std::move(strides_in)), readonly(readonly) { |
| if (ndim != (ssize_t) shape.size() || ndim != (ssize_t) strides.size()) |
| pybind11_fail("buffer_info: ndim doesn't match shape and/or strides length"); |
| for (size_t i = 0; i < (size_t) ndim; ++i) |
| size *= shape[i]; |
| } |
| |
| template <typename T> |
| buffer_info(T *ptr, detail::any_container<ssize_t> shape_in, detail::any_container<ssize_t> strides_in, bool readonly=false) |
| : buffer_info(private_ctr_tag(), ptr, sizeof(T), format_descriptor<T>::format(), static_cast<ssize_t>(shape_in->size()), std::move(shape_in), std::move(strides_in), readonly) { } |
| |
| buffer_info(void *ptr, ssize_t itemsize, const std::string &format, ssize_t size, bool readonly=false) |
| : buffer_info(ptr, itemsize, format, 1, {size}, {itemsize}, readonly) { } |
| |
| template <typename T> |
| buffer_info(T *ptr, ssize_t size, bool readonly=false) |
| : buffer_info(ptr, sizeof(T), format_descriptor<T>::format(), size, readonly) { } |
| |
| template <typename T> |
| buffer_info(const T *ptr, ssize_t size, bool readonly=true) |
| : buffer_info(const_cast<T*>(ptr), sizeof(T), format_descriptor<T>::format(), size, readonly) { } |
| |
| explicit buffer_info(Py_buffer *view, bool ownview = true) |
| : buffer_info(view->buf, view->itemsize, view->format, view->ndim, |
| {view->shape, view->shape + view->ndim}, |
| /* Though buffer::request() requests PyBUF_STRIDES, ctypes objects |
| * ignore this flag and return a view with NULL strides. |
| * When strides are NULL, build them manually. */ |
| view->strides |
| ? std::vector<ssize_t>(view->strides, view->strides + view->ndim) |
| : detail::c_strides({view->shape, view->shape + view->ndim}, view->itemsize), |
| (view->readonly != 0)) { |
| this->m_view = view; |
| this->ownview = ownview; |
| } |
| |
| buffer_info(const buffer_info &) = delete; |
| buffer_info& operator=(const buffer_info &) = delete; |
| |
| buffer_info(buffer_info &&other) noexcept { (*this) = std::move(other); } |
| |
| buffer_info &operator=(buffer_info &&rhs) noexcept { |
| ptr = rhs.ptr; |
| itemsize = rhs.itemsize; |
| size = rhs.size; |
| format = std::move(rhs.format); |
| ndim = rhs.ndim; |
| shape = std::move(rhs.shape); |
| strides = std::move(rhs.strides); |
| std::swap(m_view, rhs.m_view); |
| std::swap(ownview, rhs.ownview); |
| readonly = rhs.readonly; |
| return *this; |
| } |
| |
| ~buffer_info() { |
| if (m_view && ownview) { PyBuffer_Release(m_view); delete m_view; } |
| } |
| |
| Py_buffer *view() const { return m_view; } |
| Py_buffer *&view() { return m_view; } |
| private: |
| struct private_ctr_tag { }; |
| |
| buffer_info(private_ctr_tag, void *ptr, ssize_t itemsize, const std::string &format, ssize_t ndim, |
| detail::any_container<ssize_t> &&shape_in, detail::any_container<ssize_t> &&strides_in, bool readonly) |
| : buffer_info(ptr, itemsize, format, ndim, std::move(shape_in), std::move(strides_in), readonly) { } |
| |
| Py_buffer *m_view = nullptr; |
| bool ownview = false; |
| }; |
| |
| PYBIND11_NAMESPACE_BEGIN(detail) |
| |
| template <typename T, typename SFINAE = void> struct compare_buffer_info { |
| static bool compare(const buffer_info& b) { |
| return b.format == format_descriptor<T>::format() && b.itemsize == (ssize_t) sizeof(T); |
| } |
| }; |
| |
| template <typename T> struct compare_buffer_info<T, detail::enable_if_t<std::is_integral<T>::value>> { |
| static bool compare(const buffer_info& b) { |
| return (size_t) b.itemsize == sizeof(T) && (b.format == format_descriptor<T>::value || |
| ((sizeof(T) == sizeof(long)) && b.format == (std::is_unsigned<T>::value ? "L" : "l")) || |
| ((sizeof(T) == sizeof(size_t)) && b.format == (std::is_unsigned<T>::value ? "N" : "n"))); |
| } |
| }; |
| |
| PYBIND11_NAMESPACE_END(detail) |
| PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) |