WIP: Add support for the buffer protocol

python3-sys/src/memoryobject.rs

@@ -21,6 +21,7 @@ extern "C" {
         size: Py_ssize_t,
         flags: c_int,
     ) -> *mut PyObject;
+    pub fn PyMemoryView_FromBuffer(view: *mut Py_buffer) -> *mut PyObject;
     pub fn PyMemoryView_GetContiguous(
         base: *mut PyObject,
         buffertype: c_int,

python3-sys/src/object.rs

@@ -109,13 +109,13 @@ mod bufferinfo {
         }
     }
 
-    pub type getbufferproc = extern "C" fn(
+    pub type getbufferproc = unsafe extern "C" fn(
         arg1: *mut crate::object::PyObject,
         arg2: *mut Py_buffer,
         arg3: c_int,
     ) -> c_int;
     pub type releasebufferproc =
-        extern "C" fn(arg1: *mut crate::object::PyObject, arg2: *mut Py_buffer) -> ();
+        unsafe extern "C" fn(arg1: *mut crate::object::PyObject, arg2: *mut Py_buffer) -> ();
 
     /// Maximum number of dimensions
     pub const PyBUF_MAX_NDIM: c_int = 64;
@@ -430,6 +430,10 @@ mod typeobject {
             unsafe { core::mem::zeroed() }
         }
     }
+    pub const PyBufferProcs_INIT: PyBufferProcs = PyBufferProcs {
+        bf_getbuffer: None,
+        bf_releasebuffer: None,
+    };
 
     #[repr(C)]
     #[derive(Copy)]

src/buffer.rs

@@ -18,7 +18,7 @@
 
 use libc;
 use std::ffi::CStr;
-use std::{cell, mem, slice};
+use std::{cell, mem, ptr, slice};
 
 use crate::err::{self, PyResult};
 use crate::exc;
@@ -661,6 +661,36 @@ impl_element!(isize, SignedInteger);
 impl_element!(f32, Float);
 impl_element!(f64, Float);
 
+/// Trait for the backing storage of a PyBuffer provided from a Rust binding.
+///
+/// It is unsafe because its implementation needs to uphold certain invariants.
+/// See the method docs for more details.
+pub unsafe trait BufferHandle: 'static + Send {
+    /// Returns the data of `Self` as a continous array of bytes.
+    ///
+    /// # Safety
+    ///
+    /// This needs to return an address that remains valid
+    /// and stable if `self` gets moved or transformed to or from a void pointer.
+    fn as_bytes(&self) -> &[u8];
+
+    /// Convert `self` into an owned void pointer.
+    ///
+    /// # Safety
+    ///
+    /// The returned pointer has to be a valid pointer that
+    /// can be converted back to `Self`.
+    fn into_owned_void_pointer(self) -> *mut libc::c_void;
+
+    /// Convert an owned void pointer back to `Self`. This takes owenrship of the pointer.
+    ///
+    /// # Safety
+    ///
+    /// The passed `ptr` has been created by this trait, and is only
+    /// used at most once to convert back to `Self`.
+    unsafe fn from_owned_void_pointer(ptr: *mut libc::c_void) -> Self;
+}
+
 #[cfg(test)]
 mod test {
     use super::PyBuffer;

src/py_class/py_class.rs

@@ -465,6 +465,10 @@ macro_rules! py_class {
                 /* as_number */   [ /* slot: expr, */ ]
                 /* as_sequence */ [ /* slot: expr, */ ]
                 /* as_mapping */  [ /* slot: expr, */ ]
+                /* as_buffer */ [
+                    bf_getbuffer: {},
+                    bf_releasebuffer: {},
+                ]
                 /* setitem_delitem */ [
                     sdi_setitem: {},
                     sdi_delitem: {},
@@ -495,6 +499,10 @@ macro_rules! py_class {
                 /* as_number */   [ /* slot: expr, */ ]
                 /* as_sequence */ [ /* slot: expr, */ ]
                 /* as_mapping */  [ /* slot: expr, */ ]
+                /* as_buffer */ [
+                    bf_getbuffer: {},
+                    bf_releasebuffer: {},
+                ]
                 /* setitem_delitem */ [
                     sdi_setitem: {},
                     sdi_delitem: {},

src/py_class/py_class_impl.py

@@ -247,7 +247,8 @@ def write(text):
     ('nb', 'as_number', None),
     ('sq', 'as_sequence', None),
     ('mp', 'as_mapping', None),
-    ('sdi', 'setdelitem', ['sdi_setitem', 'sdi_delitem'])
+    ('bf', 'as_buffer', ['bf_getbuffer', 'bf_releasebuffer']),
+    ('sdi', 'setdelitem', ['sdi_setitem', 'sdi_delitem']),
 )
 
 def generate_case(pattern, old_info=None, new_info=None, new_impl=None, new_slots=None, new_members=None, new_props=None):
@@ -723,6 +724,30 @@ def inplace_numeric_operator(special_name, slot):
     operator(slot=slot,
              args=[Argument('other')])(special_name)
 
+@special_method
+def buffer_protocol(special_name, enabled, mode):
+    if enabled:
+        if mode == "direct":
+            pattern = 'def %s <$gil_lt:lifetime>(&$slf_lt:lifetime $slf:ident) -> $res_type:ty $body:block' % special_name
+            new_impl='''
+                impl $class {
+                    fn %s<$gil_lt>(&$slf_lt $slf, $py: $crate::Python<$gil_lt>) -> $res_type $body
+                }
+            ''' % special_name
+
+        if mode == "handle":
+            pattern = 'def %s (&$slf:ident) -> $res_type:ty $body:block' % special_name
+            new_impl='''
+                impl $class {
+                    fn %s(&$slf, $py: $crate::Python<'_>) -> $res_type $body
+                }
+            ''' % special_name
+
+        new_slots = []
+        for slot in ['bf_getbuffer', 'bf_releasebuffer']:
+            new_slots.append((slot, '$crate::py_class_buffer_slot!(%s, %s, $class::%s)' % (mode, slot, special_name)))
+        generate_case(pattern, new_slots=new_slots, new_impl=new_impl)
+
 special_names = {
     '__init__': error('__init__ is not supported by py_class!; use __new__ instead.'),
     '__new__': special_class_method(
@@ -870,6 +895,10 @@ def inplace_numeric_operator(special_name, slot):
     '__aiter__': unimplemented(),
     '__aenter__': unimplemented(),
     '__aexit__': unimplemented(),
+
+    # Buffer protocol
+    '__buffer__': buffer_protocol(not PY2, "handle"),
+    '__direct_buffer__': buffer_protocol(not PY2, "direct"),
 }
 
 def main():
@@ -907,4 +936,3 @@ def main():
 
 if __name__ == '__main__':
     main()
-