Spaces:
Sleeping
Sleeping
| /* Public Py_buffer API */ | |
| extern "C" { | |
| /* === New Buffer API ============================================ | |
| * Limited API and stable ABI since Python 3.11 | |
| * | |
| * Py_buffer struct layout and size is now part of the stable abi3. The | |
| * struct layout and size must not be changed in any way, as it would | |
| * break the ABI. | |
| * | |
| */ | |
| typedef struct { | |
| void *buf; | |
| PyObject *obj; /* owned reference */ | |
| Py_ssize_t len; | |
| Py_ssize_t itemsize; /* This is Py_ssize_t so it can be | |
| pointed to by strides in simple case.*/ | |
| int readonly; | |
| int ndim; | |
| char *format; | |
| Py_ssize_t *shape; | |
| Py_ssize_t *strides; | |
| Py_ssize_t *suboffsets; | |
| void *internal; | |
| } Py_buffer; | |
| /* Return 1 if the getbuffer function is available, otherwise return 0. */ | |
| PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject *obj); | |
| /* This is a C-API version of the getbuffer function call. It checks | |
| to make sure object has the required function pointer and issues the | |
| call. | |
| Returns -1 and raises an error on failure and returns 0 on success. */ | |
| PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view, | |
| int flags); | |
| /* Get the memory area pointed to by the indices for the buffer given. | |
| Note that view->ndim is the assumed size of indices. */ | |
| PyAPI_FUNC(void *) PyBuffer_GetPointer(const Py_buffer *view, const Py_ssize_t *indices); | |
| /* Return the implied itemsize of the data-format area from a | |
| struct-style description. */ | |
| PyAPI_FUNC(Py_ssize_t) PyBuffer_SizeFromFormat(const char *format); | |
| /* Implementation in memoryobject.c */ | |
| PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, const Py_buffer *view, | |
| Py_ssize_t len, char order); | |
| PyAPI_FUNC(int) PyBuffer_FromContiguous(const Py_buffer *view, const void *buf, | |
| Py_ssize_t len, char order); | |
| /* Copy len bytes of data from the contiguous chunk of memory | |
| pointed to by buf into the buffer exported by obj. Return | |
| 0 on success and return -1 and raise a PyBuffer_Error on | |
| error (i.e. the object does not have a buffer interface or | |
| it is not working). | |
| If fort is 'F', then if the object is multi-dimensional, | |
| then the data will be copied into the array in | |
| Fortran-style (first dimension varies the fastest). If | |
| fort is 'C', then the data will be copied into the array | |
| in C-style (last dimension varies the fastest). If fort | |
| is 'A', then it does not matter and the copy will be made | |
| in whatever way is more efficient. */ | |
| PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src); | |
| /* Copy the data from the src buffer to the buffer of destination. */ | |
| PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort); | |
| /*Fill the strides array with byte-strides of a contiguous | |
| (Fortran-style if fort is 'F' or C-style otherwise) | |
| array of the given shape with the given number of bytes | |
| per element. */ | |
| PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, | |
| Py_ssize_t *shape, | |
| Py_ssize_t *strides, | |
| int itemsize, | |
| char fort); | |
| /* Fills in a buffer-info structure correctly for an exporter | |
| that can only share a contiguous chunk of memory of | |
| "unsigned bytes" of the given length. | |
| Returns 0 on success and -1 (with raising an error) on error. */ | |
| PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf, | |
| Py_ssize_t len, int readonly, | |
| int flags); | |
| /* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */ | |
| PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view); | |
| /* Maximum number of dimensions */ | |
| /* Flags for getting buffers */ | |
| /* we used to include an E, backwards compatible alias */ | |
| } | |