1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

// Copyright (c) 2017-present PyO3 Project and Contributors

//! Represent Python Buffer protocol implementation
//!
//! For more information check [buffer protocol](https://docs.python.org/3/c-api/buffer.html)
//! c-api
use crate::callback::UnitCallbackConverter;
use crate::err::PyResult;
use crate::{ffi, PyClass, PyRefMut};
use std::os::raw::c_int;

/// Buffer protocol interface
///
/// For more information check [buffer protocol](https://docs.python.org/3/c-api/buffer.html)
/// c-api
#[allow(unused_variables)]
pub trait PyBufferProtocol<'p>: PyClass {
    fn bf_getbuffer(slf: PyRefMut<Self>, view: *mut ffi::Py_buffer, flags: c_int) -> Self::Result
    where
        Self: PyBufferGetBufferProtocol<'p>,
    {
        unimplemented!()
    }

    fn bf_releasebuffer(slf: PyRefMut<Self>, view: *mut ffi::Py_buffer) -> Self::Result
    where
        Self: PyBufferReleaseBufferProtocol<'p>,
    {
        unimplemented!()
    }
}

pub trait PyBufferGetBufferProtocol<'p>: PyBufferProtocol<'p> {
    type Result: Into<PyResult<()>>;
}

pub trait PyBufferReleaseBufferProtocol<'p>: PyBufferProtocol<'p> {
    type Result: Into<PyResult<()>>;
}

#[doc(hidden)]
pub trait PyBufferProtocolImpl {
    fn tp_as_buffer() -> Option<ffi::PyBufferProcs>;
}

impl<T> PyBufferProtocolImpl for T {
    default fn tp_as_buffer() -> Option<ffi::PyBufferProcs> {
        None
    }
}

impl<'p, T> PyBufferProtocolImpl for T
where
    T: PyBufferProtocol<'p>,
{
    #[inline]
    #[allow(clippy::needless_update)] // For python 2 it's not useless
    fn tp_as_buffer() -> Option<ffi::PyBufferProcs> {
        Some(ffi::PyBufferProcs {
            bf_getbuffer: Self::cb_bf_getbuffer(),
            bf_releasebuffer: Self::cb_bf_releasebuffer(),
            ..ffi::PyBufferProcs_INIT
        })
    }
}

trait PyBufferGetBufferProtocolImpl {
    fn cb_bf_getbuffer() -> Option<ffi::getbufferproc>;
}

impl<'p, T> PyBufferGetBufferProtocolImpl for T
where
    T: PyBufferProtocol<'p>,
{
    default fn cb_bf_getbuffer() -> Option<ffi::getbufferproc> {
        None
    }
}

impl<T> PyBufferGetBufferProtocolImpl for T
where
    T: for<'p> PyBufferGetBufferProtocol<'p>,
{
    #[inline]
    fn cb_bf_getbuffer() -> Option<ffi::getbufferproc> {
        unsafe extern "C" fn wrap<T>(
            slf: *mut ffi::PyObject,
            arg1: *mut ffi::Py_buffer,
            arg2: c_int,
        ) -> c_int
        where
            T: for<'p> PyBufferGetBufferProtocol<'p>,
        {
            let py = crate::Python::assume_gil_acquired();
            let _pool = crate::GILPool::new(py);
            let slf = py.from_borrowed_ptr::<crate::PyCell<T>>(slf);
            let result = slf
                .try_borrow_mut()
                .map_err(crate::PyErr::from)
                .and_then(|slf_mut| T::bf_getbuffer(slf_mut, arg1, arg2).into());
            crate::callback::cb_convert(UnitCallbackConverter, py, result)
        }
        Some(wrap::<T>)
    }
}

trait PyBufferReleaseBufferProtocolImpl {
    fn cb_bf_releasebuffer() -> Option<ffi::releasebufferproc>;
}

impl<'p, T> PyBufferReleaseBufferProtocolImpl for T
where
    T: PyBufferProtocol<'p>,
{
    default fn cb_bf_releasebuffer() -> Option<ffi::releasebufferproc> {
        None
    }
}

impl<T> PyBufferReleaseBufferProtocolImpl for T
where
    T: for<'p> PyBufferReleaseBufferProtocol<'p>,
{
    #[inline]
    fn cb_bf_releasebuffer() -> Option<ffi::releasebufferproc> {
        unsafe extern "C" fn wrap<T>(slf: *mut ffi::PyObject, arg1: *mut ffi::Py_buffer)
        where
            T: for<'p> PyBufferReleaseBufferProtocol<'p>,
        {
            let py = crate::Python::assume_gil_acquired();
            let _pool = crate::GILPool::new(py);
            let slf = py.from_borrowed_ptr::<crate::PyCell<T>>(slf);
            let result = slf
                .try_borrow_mut()
                .map_err(crate::PyErr::from)
                .and_then(|slf_mut| T::bf_releasebuffer(slf_mut, arg1).into());
            crate::callback::cb_convert(UnitCallbackConverter, py, result);
        }
        Some(wrap::<T>)
    }
}