refactor ToPyObject
This commit is contained in:
parent
b8913a3705
commit
3040ac12b9
|
@ -1,16 +1,16 @@
|
|||
use ffi;
|
||||
use err::PyResult;
|
||||
use pointers::{pptr, PyPtr};
|
||||
use pointers::pptr;
|
||||
use python::{Python, ToPythonPointer};
|
||||
use objects::{PyObject, PyTuple};
|
||||
use token::PyObjectMarker;
|
||||
use native::PyNativeObject;
|
||||
|
||||
|
||||
/// Conversion trait that allows various objects to be converted into PyObject
|
||||
pub trait ToPyObject {
|
||||
|
||||
/// Converts self into a Python object.
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyPtr<PyObjectMarker>;
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p>;
|
||||
|
||||
/// Converts self into a Python object and calls the specified closure
|
||||
/// on the native FFI pointer underlying the Python object.
|
||||
|
@ -113,7 +113,7 @@ impl<T> IntoPyObject for T where T: ToPyObject
|
|||
impl <'a, T: ?Sized> ToPyObject for &'a T where T: ToPyObject {
|
||||
|
||||
#[inline]
|
||||
default fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
default fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
<T as ToPyObject>::to_object(*self, py)
|
||||
}
|
||||
|
||||
|
@ -129,10 +129,10 @@ impl <'a, T: ?Sized> ToPyObject for &'a T where T: ToPyObject {
|
|||
/// `Option::None` is converted to Python `None`.
|
||||
impl <T> ToPyObject for Option<T> where T: ToPyObject {
|
||||
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
match *self {
|
||||
Some(ref val) => val.to_object(py),
|
||||
None => py.None().into_pobject(),
|
||||
None => py.None().into_object(py),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -150,8 +150,8 @@ impl<T> IntoPyObject for Option<T> where T: IntoPyObject {
|
|||
|
||||
/// `()` is converted to Python `None`.
|
||||
impl ToPyObject for () {
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
py.None().into_pobject()
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
py.None().into_object(py)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
21
src/err.rs
21
src/err.rs
|
@ -4,11 +4,10 @@ use std::os::raw::c_char;
|
|||
use libc;
|
||||
|
||||
use ffi;
|
||||
use pointers::{pptr, PyPtr};
|
||||
use pointers::pptr;
|
||||
use python::{ToPythonPointer, IntoPythonPointer, Python};
|
||||
use objects::{PyObject, PyType, exc};
|
||||
use native::PyNativeObject;
|
||||
use token::PyObjectMarker;
|
||||
use typeob::{PyTypeObject};
|
||||
use conversion::{ToPyObject, ToPyTuple, IntoPyObject};
|
||||
|
||||
|
@ -117,9 +116,9 @@ impl PyErr {
|
|||
/// Example:
|
||||
/// `return Err(PyErr::new::<exc::TypeError, _>(py, "Error message"));`
|
||||
pub fn new<T, V>(py: Python, value: V) -> PyErr
|
||||
where T: PyTypeObject, V: ToPyObject
|
||||
where T: PyTypeObject, V: IntoPyObject
|
||||
{
|
||||
PyErr::new_helper(py, py.get_type::<T>().park(), value.to_object(py))
|
||||
PyErr::new_helper(py, py.get_type::<T>().park(), value.into_object(py))
|
||||
}
|
||||
|
||||
/// Gets whether an error is present in the Python interpreter's global state.
|
||||
|
@ -184,11 +183,11 @@ impl PyErr {
|
|||
}
|
||||
}
|
||||
|
||||
fn new_helper(_py: Python, ty: pptr, value: PyPtr<PyObjectMarker>) -> PyErr {
|
||||
fn new_helper(_py: Python, ty: pptr, value: pptr) -> PyErr {
|
||||
assert!(unsafe { ffi::PyExceptionClass_Check(ty.as_ptr()) } != 0);
|
||||
PyErr {
|
||||
ptype: ty,
|
||||
pvalue: Some(value.park()),
|
||||
pvalue: Some(value),
|
||||
ptraceback: None
|
||||
}
|
||||
}
|
||||
|
@ -198,21 +197,21 @@ impl PyErr {
|
|||
/// `obj` must be an Python exception instance, the PyErr will use that instance.
|
||||
/// If `obj` is a Python exception type object, the PyErr will (lazily) create a new instance of that type.
|
||||
/// Otherwise, a `TypeError` is created instead.
|
||||
pub fn from_instance<O>(py: Python, obj: O) -> PyErr where O: ToPyObject {
|
||||
PyErr::from_instance_helper(py, obj.to_object(py))
|
||||
pub fn from_instance<O>(py: Python, obj: O) -> PyErr where O: IntoPyObject {
|
||||
PyErr::from_instance_helper(py, obj.into_object(py))
|
||||
}
|
||||
|
||||
fn from_instance_helper<'p>(py: Python, obj: PyPtr<PyObjectMarker>) -> PyErr {
|
||||
fn from_instance_helper<'p>(py: Python, obj: pptr) -> PyErr {
|
||||
if unsafe { ffi::PyExceptionInstance_Check(obj.as_ptr()) } != 0 {
|
||||
PyErr {
|
||||
ptype: unsafe { pptr::from_borrowed_ptr(
|
||||
ffi::PyExceptionInstance_Class(obj.as_ptr())) },
|
||||
pvalue: Some(obj.park()),
|
||||
pvalue: Some(obj),
|
||||
ptraceback: None
|
||||
}
|
||||
} else if unsafe { ffi::PyExceptionClass_Check(obj.as_ptr()) } != 0 {
|
||||
PyErr {
|
||||
ptype: obj.park(),
|
||||
ptype: obj,
|
||||
pvalue: None,
|
||||
ptraceback: None
|
||||
}
|
||||
|
|
|
@ -71,7 +71,7 @@ mod ppptr;
|
|||
pub use ppptr::{pyptr};
|
||||
|
||||
mod token;
|
||||
pub use token::{PyObjectMarker, PythonToken, PythonObjectWithToken, PythonObjectWithGilToken};
|
||||
pub use token::{PythonToken, PythonObjectWithToken, PythonObjectWithGilToken};
|
||||
|
||||
pub use err::{PyErr, PyResult, PyDowncastError};
|
||||
pub use objects::*;
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
// Copyright (c) 2017-present PyO3 Project and Contributors
|
||||
|
||||
use pointers::{pptr, PyPtr};
|
||||
use token::PyObjectMarker;
|
||||
use pointers::pptr;
|
||||
use objects::PyObject;
|
||||
|
||||
pub trait PyBaseObject : Sized {}
|
||||
|
@ -12,8 +11,6 @@ pub trait PyNativeObject<'p> : PyBaseObject {
|
|||
|
||||
fn as_object(self) -> PyObject<'p>;
|
||||
|
||||
fn into_object(self) -> PyPtr<PyObjectMarker>;
|
||||
|
||||
fn clone_object(&self) -> Self;
|
||||
|
||||
}
|
||||
|
|
|
@ -479,7 +479,7 @@ mod test {
|
|||
use std::cmp::Ordering;
|
||||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let one = 1i32.to_object(py).into_object(py);
|
||||
let one = 1i32.to_object(py);
|
||||
assert_eq!(one.compare(1).unwrap(), Ordering::Equal);
|
||||
assert_eq!(one.compare(2).unwrap(), Ordering::Less);
|
||||
assert_eq!(one.compare(0).unwrap(), Ordering::Greater);
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
use ::{pyptr, PyPtr};
|
||||
use pyptr;
|
||||
use ffi;
|
||||
use token::PyObjectMarker;
|
||||
use python::{ToPythonPointer, Python};
|
||||
use objects::PyObject;
|
||||
use native::PyNativeObject;
|
||||
use conversion::ToPyObject;
|
||||
|
||||
|
@ -29,8 +29,8 @@ impl<'p> PyBool<'p> {
|
|||
/// Converts a rust `bool` to a Python `bool`.
|
||||
impl ToPyObject for bool {
|
||||
#[inline]
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
PyBool::new(py, *self).into_object()
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyBool::new(py, *self).as_object()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
@ -62,7 +62,7 @@ mod test {
|
|||
let py = gil.python();
|
||||
assert!(py.True().is_true());
|
||||
assert_eq!(true, py.True().as_object().extract().unwrap());
|
||||
assert!(true.to_object(py).into_object(py) == py.True().as_object());
|
||||
assert!(true.to_object(py) == py.True().as_object());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
@ -71,6 +71,6 @@ mod test {
|
|||
let py = gil.python();
|
||||
assert!(!py.False().is_true());
|
||||
assert_eq!(false, py.False().as_object().extract().unwrap());
|
||||
assert!(false.to_object(py).into_object(py) == py.False().as_object());
|
||||
assert!(false.to_object(py) == py.False().as_object());
|
||||
}
|
||||
}
|
||||
|
|
|
@ -93,7 +93,7 @@ mod test {
|
|||
assert_eq!(src, bytearray.data());
|
||||
|
||||
let ba = bytearray.to_object(py);
|
||||
let bytearray = PyByteArray::from(ba.as_object(py)).unwrap();
|
||||
let bytearray = PyByteArray::from(&ba).unwrap();
|
||||
assert_eq!(src.len(), bytearray.len());
|
||||
assert_eq!(src, bytearray.data());
|
||||
|
||||
|
|
|
@ -2,15 +2,16 @@
|
|||
//
|
||||
// based on Daniel Grunwald's https://github.com/dgrunwald/rust-cpython
|
||||
|
||||
use ::pyptr;
|
||||
use std::{mem, collections, hash, cmp};
|
||||
|
||||
use ffi;
|
||||
use pointers::PyPtr;
|
||||
use pyptr;
|
||||
use python::{Python, ToPythonPointer, PyDowncastInto};
|
||||
use conversion::{ToPyObject};
|
||||
use objects::{PyObject, PyList};
|
||||
use token::{PyObjectMarker, PythonObjectWithGilToken};
|
||||
use token::PythonObjectWithGilToken;
|
||||
use err::{self, PyResult, PyErr};
|
||||
use std::{mem, collections, hash, cmp};
|
||||
use native::PyNativeObject;
|
||||
|
||||
/// Represents a Python `dict`.
|
||||
pub struct PyDict<'p>(pyptr<'p>);
|
||||
|
@ -129,12 +130,12 @@ impl <K, V> ToPyObject for collections::HashMap<K, V>
|
|||
where K: hash::Hash+cmp::Eq+ToPyObject,
|
||||
V: ToPyObject
|
||||
{
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
let dict = PyDict::new(py);
|
||||
for (key, value) in self {
|
||||
dict.set_item(key, value).unwrap();
|
||||
};
|
||||
dict.to_object(py)
|
||||
dict.as_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -142,19 +143,19 @@ impl <K, V> ToPyObject for collections::BTreeMap<K, V>
|
|||
where K: cmp::Eq+ToPyObject,
|
||||
V: ToPyObject
|
||||
{
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
let dict = PyDict::new(py);
|
||||
for (key, value) in self {
|
||||
dict.set_item(key, value).unwrap();
|
||||
};
|
||||
dict.to_object(py)
|
||||
dict.as_object()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use python::{Python, PyDowncastInto};
|
||||
use python::Python;
|
||||
use conversion::ToPyObject;
|
||||
use objects::{PyDict, PyTuple};
|
||||
use ::PyDowncastFrom;
|
||||
|
@ -166,11 +167,11 @@ mod test {
|
|||
let py = gil.python();
|
||||
let mut v = HashMap::new();
|
||||
let ob = v.to_object(py);
|
||||
let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
|
||||
let dict = PyDict::downcast_from(&ob).unwrap();
|
||||
assert_eq!(0, dict.len());
|
||||
v.insert(7, 32);
|
||||
let ob = v.to_object(py);
|
||||
let dict2 = PyDict::downcast_from(ob.as_object(py)).unwrap();
|
||||
let dict2 = PyDict::downcast_from(&ob).unwrap();
|
||||
assert_eq!(1, dict2.len());
|
||||
}
|
||||
|
||||
|
@ -181,7 +182,7 @@ mod test {
|
|||
let mut v = HashMap::new();
|
||||
v.insert(7, 32);
|
||||
let ob = v.to_object(py);
|
||||
let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
|
||||
let dict = PyDict::downcast_from(&ob).unwrap();
|
||||
assert_eq!(true, dict.contains(7i32).unwrap());
|
||||
assert_eq!(false, dict.contains(8i32).unwrap());
|
||||
}
|
||||
|
@ -193,7 +194,7 @@ mod test {
|
|||
let mut v = HashMap::new();
|
||||
v.insert(7, 32);
|
||||
let ob = v.to_object(py);
|
||||
let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
|
||||
let dict = PyDict::downcast_from(&ob).unwrap();
|
||||
assert_eq!(32, dict.get_item(7i32).unwrap().extract::<i32>().unwrap());
|
||||
assert_eq!(None, dict.get_item(8i32));
|
||||
}
|
||||
|
@ -205,7 +206,7 @@ mod test {
|
|||
let mut v = HashMap::new();
|
||||
v.insert(7, 32);
|
||||
let ob = v.to_object(py);
|
||||
let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
|
||||
let dict = PyDict::downcast_from(&ob).unwrap();
|
||||
assert!(dict.set_item(7i32, 42i32).is_ok()); // change
|
||||
assert!(dict.set_item(8i32, 123i32).is_ok()); // insert
|
||||
assert_eq!(42i32, dict.get_item(7i32).unwrap().extract::<i32>().unwrap());
|
||||
|
@ -219,7 +220,7 @@ mod test {
|
|||
let mut v = HashMap::new();
|
||||
v.insert(7, 32);
|
||||
let ob = v.to_object(py);
|
||||
let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
|
||||
let dict = PyDict::downcast_from(&ob).unwrap();
|
||||
assert!(dict.set_item(7i32, 42i32).is_ok()); // change
|
||||
assert!(dict.set_item(8i32, 123i32).is_ok()); // insert
|
||||
assert_eq!(32i32, *v.get(&7i32).unwrap()); // not updated!
|
||||
|
@ -234,7 +235,7 @@ mod test {
|
|||
let mut v = HashMap::new();
|
||||
v.insert(7, 32);
|
||||
let ob = v.to_object(py);
|
||||
let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
|
||||
let dict = PyDict::downcast_from(&ob).unwrap();
|
||||
assert!(dict.del_item(7i32).is_ok());
|
||||
assert_eq!(0, dict.len());
|
||||
assert_eq!(None, dict.get_item(7i32));
|
||||
|
@ -247,7 +248,7 @@ mod test {
|
|||
let mut v = HashMap::new();
|
||||
v.insert(7, 32);
|
||||
let ob = v.to_object(py);
|
||||
let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
|
||||
let dict = PyDict::downcast_from(&ob).unwrap();
|
||||
assert!(dict.del_item(7i32).is_ok()); // change
|
||||
assert_eq!(32i32, *v.get(&7i32).unwrap()); // not updated!
|
||||
}
|
||||
|
@ -260,7 +261,8 @@ mod test {
|
|||
v.insert(7, 32);
|
||||
v.insert(8, 42);
|
||||
v.insert(9, 123);
|
||||
let dict = PyDict::downcast_into(py, v.to_object(py)).unwrap();
|
||||
let ob = v.to_object(py);
|
||||
let dict = PyDict::downcast_from(&ob).unwrap();
|
||||
// Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
|
||||
let mut key_sum = 0;
|
||||
let mut value_sum = 0;
|
||||
|
@ -282,7 +284,7 @@ mod test {
|
|||
v.insert(8, 42);
|
||||
v.insert(9, 123);
|
||||
let ob = v.to_object(py);
|
||||
let dict = PyDict::downcast_from(ob.as_object(py)).unwrap();
|
||||
let dict = PyDict::downcast_from(&ob).unwrap();
|
||||
// Can't just compare against a vector of tuples since we don't have a guaranteed ordering.
|
||||
let mut key_sum = 0;
|
||||
let mut value_sum = 0;
|
||||
|
@ -303,7 +305,7 @@ mod test {
|
|||
map.insert(1, 1);
|
||||
|
||||
let m = map.to_object(py);
|
||||
let py_map = PyDict::downcast_from(m.as_object(py)).unwrap();
|
||||
let py_map = PyDict::downcast_from(&m).unwrap();
|
||||
|
||||
assert!(py_map.len() == 1);
|
||||
assert!( py_map.get_item(1).unwrap().extract::<i32>().unwrap() == 1);
|
||||
|
@ -318,7 +320,7 @@ mod test {
|
|||
map.insert(1, 1);
|
||||
|
||||
let m = map.to_object(py);
|
||||
let py_map = PyDict::downcast_from(m.as_object(py)).unwrap();
|
||||
let py_map = PyDict::downcast_from(&m).unwrap();
|
||||
|
||||
assert!(py_map.len() == 1);
|
||||
assert!( py_map.get_item(1).unwrap().extract::<i32>().unwrap() == 1);
|
||||
|
|
|
@ -66,7 +66,7 @@ mod tests {
|
|||
fn vec_iter() {
|
||||
let gil_guard = Python::acquire_gil();
|
||||
let py = gil_guard.python();
|
||||
let obj = vec![10, 20].to_object(py).into_object(py);
|
||||
let obj = vec![10, 20].to_object(py);
|
||||
let mut it = obj.iter().unwrap();
|
||||
assert_eq!(10, it.next().unwrap().unwrap().extract().unwrap());
|
||||
assert_eq!(20, it.next().unwrap().unwrap().extract().unwrap());
|
||||
|
|
|
@ -5,10 +5,9 @@
|
|||
use ::pyptr;
|
||||
use err::{self, PyResult};
|
||||
use ffi::{self, Py_ssize_t};
|
||||
use pointers::PyPtr;
|
||||
use python::{Python, ToPythonPointer, IntoPythonPointer};
|
||||
use objects::PyObject;
|
||||
use token::{PyObjectMarker, PythonObjectWithGilToken};
|
||||
use token::PythonObjectWithGilToken;
|
||||
use conversion::{ToPyObject, IntoPyObject};
|
||||
|
||||
/// Represents a Python `list`.
|
||||
|
@ -103,21 +102,21 @@ impl <'p> Iterator for PyListIterator<'p> {
|
|||
|
||||
impl <T> ToPyObject for [T] where T: ToPyObject {
|
||||
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
unsafe {
|
||||
let ptr = ffi::PyList_New(self.len() as Py_ssize_t);
|
||||
for (i, e) in self.iter().enumerate() {
|
||||
let obj = e.to_object(py).into_ptr();
|
||||
ffi::PyList_SetItem(ptr, i as Py_ssize_t, obj);
|
||||
}
|
||||
PyPtr::from_owned_ptr_or_panic(ptr)
|
||||
PyObject::from_owned_ptr_or_panic(py, ptr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl <T> ToPyObject for Vec<T> where T: ToPyObject {
|
||||
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
self.as_slice().to_object(py)
|
||||
}
|
||||
|
||||
|
@ -170,7 +169,7 @@ mod test {
|
|||
let py = gil.python();
|
||||
let v = vec![2, 3, 5, 7];
|
||||
let list = PyList::downcast_into(py, v.to_object(py)).unwrap();
|
||||
let val = 42i32.to_object(py).into_object(py);
|
||||
let val = 42i32.to_object(py);
|
||||
assert_eq!(2, list.get_item(0).extract::<i32>().unwrap());
|
||||
list.set_item(0, val).unwrap();
|
||||
assert_eq!(42, list.get_item(0).extract::<i32>().unwrap());
|
||||
|
@ -182,7 +181,7 @@ mod test {
|
|||
let py = gil.python();
|
||||
let v = vec![2, 3, 5, 7];
|
||||
let list = PyList::downcast_into(py, v.to_object(py)).unwrap();
|
||||
let val = 42i32.to_object(py).into_object(py);
|
||||
let val = 42i32.to_object(py);
|
||||
assert_eq!(4, list.len());
|
||||
assert_eq!(2, list.get_item(0).extract::<i32>().unwrap());
|
||||
list.insert_item(0, val).unwrap();
|
||||
|
|
|
@ -57,9 +57,6 @@ macro_rules! pyobject_nativetype(
|
|||
fn as_object(self) -> $crate::PyObject<'p> {
|
||||
unsafe { $crate::std::mem::transmute(self) }
|
||||
}
|
||||
fn into_object(self) -> $crate::PyPtr<$crate::PyObjectMarker> {
|
||||
unsafe { $crate::std::mem::transmute(self) }
|
||||
}
|
||||
fn clone_object(&self) -> $name<'p> {
|
||||
use $crate::{ToPythonPointer, PythonObjectWithGilToken};
|
||||
unsafe {
|
||||
|
@ -177,9 +174,8 @@ macro_rules! pyobject_nativetype(
|
|||
impl<'a> $crate::ToPyObject for $name<'a>
|
||||
{
|
||||
#[inline]
|
||||
fn to_object<'p>(&self, _py: $crate::Python<'p>)
|
||||
-> $crate::PyPtr<$crate::PyObjectMarker> {
|
||||
unsafe { $crate::PyPtr::from_borrowed_ptr(self.0.as_ptr()) }
|
||||
fn to_object<'p>(&self, py: $crate::Python<'p>) -> $crate::PyObject<'p> {
|
||||
$crate::PyObject::from_borrowed_ptr(py, self.0.as_ptr())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
|
|
@ -7,13 +7,14 @@ extern crate num_traits;
|
|||
use self::num_traits::cast::cast;
|
||||
use std::os::raw::{c_long, c_double};
|
||||
|
||||
use ::{PyPtr, pyptr};
|
||||
use ffi;
|
||||
use super::exc;
|
||||
use pyptr;
|
||||
use objects::exc;
|
||||
use objects::PyObject;
|
||||
use token::{PyObjectMarker, PythonObjectWithGilToken};
|
||||
use token::PythonObjectWithGilToken;
|
||||
use python::{ToPythonPointer, Python};
|
||||
use err::{PyResult, PyErr};
|
||||
use native::PyNativeObject;
|
||||
use conversion::{ToPyObject, FromPyObject};
|
||||
|
||||
/// Represents a Python `int` object.
|
||||
|
@ -53,9 +54,9 @@ impl<'p> PyFloat<'p> {
|
|||
macro_rules! int_fits_c_long(
|
||||
($rust_type:ty) => (
|
||||
impl ToPyObject for $rust_type {
|
||||
fn to_object(&self, _py: Python) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
unsafe {
|
||||
PyPtr::from_owned_ptr_or_panic(ffi::PyLong_FromLong(*self as c_long))
|
||||
PyObject::from_owned_ptr_or_panic(py, ffi::PyLong_FromLong(*self as c_long))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -78,7 +79,7 @@ macro_rules! int_fits_larger_int(
|
|||
($rust_type:ty, $larger_type:ty) => (
|
||||
impl ToPyObject for $rust_type {
|
||||
#[inline]
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
(*self as $larger_type).to_object(py)
|
||||
}
|
||||
}
|
||||
|
@ -108,10 +109,10 @@ fn err_if_invalid_value<'p, T: PartialEq>
|
|||
macro_rules! int_convert_u64_or_i64 (
|
||||
($rust_type:ty, $pylong_from_ll_or_ull:expr, $pylong_as_ull_or_ull:expr) => (
|
||||
impl ToPyObject for $rust_type {
|
||||
|
||||
fn to_object(&self, _py: Python) -> PyPtr<PyObjectMarker> {
|
||||
#[inline]
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
unsafe {
|
||||
PyPtr::from_owned_ptr_or_panic($pylong_from_ll_or_ull(*self))
|
||||
PyObject::from_owned_ptr_or_panic(py, $pylong_from_ll_or_ull(*self))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -169,8 +170,8 @@ int_fits_larger_int!(usize, u64);
|
|||
int_convert_u64_or_i64!(u64, ffi::PyLong_FromUnsignedLongLong, ffi::PyLong_AsUnsignedLongLong);
|
||||
|
||||
impl ToPyObject for f64 {
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
PyFloat::new(py, *self).to_object(py)
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyFloat::new(py, *self).as_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -188,8 +189,8 @@ fn overflow_error(py: Python) -> PyErr {
|
|||
}
|
||||
|
||||
impl ToPyObject for f32 {
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
PyFloat::new(py, *self as f64).to_object(py)
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyFloat::new(py, *self as f64).as_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -210,7 +211,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let val = 123 as $t1;
|
||||
let obj = val.to_object(py).into_object(py);
|
||||
let obj = val.to_object(py);
|
||||
assert_eq!(obj.extract::<$t2>().unwrap(), val as $t2);
|
||||
}
|
||||
)
|
||||
|
@ -239,7 +240,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = std::u32::MAX;
|
||||
let obj = v.to_object(py).into_object(py);
|
||||
let obj = v.to_object(py);
|
||||
assert_eq!(v, obj.extract::<u32>().unwrap());
|
||||
assert_eq!(v as u64, obj.extract::<u64>().unwrap());
|
||||
assert!(obj.extract::<i32>().is_err());
|
||||
|
@ -250,7 +251,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = std::i64::MAX;
|
||||
let obj = v.to_object(py).into_object(py);
|
||||
let obj = v.to_object(py);
|
||||
assert_eq!(v, obj.extract::<i64>().unwrap());
|
||||
assert_eq!(v as u64, obj.extract::<u64>().unwrap());
|
||||
assert!(obj.extract::<u32>().is_err());
|
||||
|
@ -261,7 +262,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = std::i64::MIN;
|
||||
let obj = v.to_object(py).into_object(py);
|
||||
let obj = v.to_object(py);
|
||||
assert_eq!(v, obj.extract::<i64>().unwrap());
|
||||
assert!(obj.extract::<i32>().is_err());
|
||||
assert!(obj.extract::<u64>().is_err());
|
||||
|
@ -272,7 +273,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = std::u64::MAX;
|
||||
let obj = v.to_object(py).into_object(py);
|
||||
let obj = v.to_object(py);
|
||||
assert_eq!(v, obj.extract::<u64>().unwrap());
|
||||
assert!(obj.extract::<i64>().is_err());
|
||||
}
|
||||
|
|
|
@ -26,6 +26,12 @@ impl<'p> PyObject<'p> {
|
|||
unsafe { Ok(PyObject(pyptr::from_owned_ptr_or_err(py, ptr)?)) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_owned_ptr_or_panic(py: Python<'p>, ptr: *mut ffi::PyObject)
|
||||
-> PyObject<'p> {
|
||||
unsafe { PyObject(pyptr::from_owned_ptr_or_panic(py, ptr)) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_owned_ptr_or_opt(py: Python<'p>, ptr: *mut ffi::PyObject)
|
||||
-> Option<PyObject<'p>> {
|
||||
|
|
|
@ -259,7 +259,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = 42i32;
|
||||
assert!(v.to_object(py).into_object(py).cast_into::<PySequence>(py).is_err());
|
||||
assert!(v.to_object(py).cast_into::<PySequence>(py).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
@ -267,17 +267,17 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = "London Calling";
|
||||
assert!(v.to_object(py).into_object(py).cast_into::<PySequence>(py).is_ok());
|
||||
assert!(v.to_object(py).cast_into::<PySequence>(py).is_ok());
|
||||
}
|
||||
#[test]
|
||||
fn test_seq_empty() {
|
||||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v : Vec<i32> = vec![];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
assert_eq!(0, seq.len().unwrap());
|
||||
|
||||
let needle = 7i32.to_object(py).into_object(py);
|
||||
let needle = 7i32.to_object(py);
|
||||
assert_eq!(false, seq.contains(&needle).unwrap());
|
||||
}
|
||||
|
||||
|
@ -286,16 +286,16 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
assert_eq!(6, seq.len().unwrap());
|
||||
|
||||
let bad_needle = 7i32.to_object(py).into_object(py);
|
||||
let bad_needle = 7i32.to_object(py);
|
||||
assert_eq!(false, seq.contains(&bad_needle).unwrap());
|
||||
|
||||
let good_needle = 8i32.to_object(py).into_object(py);
|
||||
let good_needle = 8i32.to_object(py);
|
||||
assert_eq!(true, seq.contains(&good_needle).unwrap());
|
||||
|
||||
let type_coerced_needle = 8f32.to_object(py).into_object(py);
|
||||
let type_coerced_needle = 8f32.to_object(py);
|
||||
assert_eq!(true, seq.contains(&type_coerced_needle).unwrap());
|
||||
}
|
||||
|
||||
|
@ -304,7 +304,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
assert_eq!(1, seq.get_item(0).unwrap().extract::<i32>().unwrap());
|
||||
assert_eq!(1, seq.get_item(1).unwrap().extract::<i32>().unwrap());
|
||||
assert_eq!(2, seq.get_item(2).unwrap().extract::<i32>().unwrap());
|
||||
|
@ -328,7 +328,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
assert!(seq.del_item(10).is_err());
|
||||
assert_eq!(1, seq.get_item(0).unwrap().extract::<i32>().unwrap());
|
||||
assert!(seq.del_item(0).is_ok());
|
||||
|
@ -351,7 +351,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
assert_eq!(0, seq.index(1i32).unwrap());
|
||||
assert_eq!(2, seq.index(2i32).unwrap());
|
||||
assert_eq!(3, seq.index(3i32).unwrap());
|
||||
|
@ -365,7 +365,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
assert_eq!(2, seq.count(1i32).unwrap());
|
||||
assert_eq!(1, seq.count(2i32).unwrap());
|
||||
assert_eq!(1, seq.count(3i32).unwrap());
|
||||
|
@ -379,7 +379,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v : Vec<i32> = vec![1, 1, 2, 3, 5, 8];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let mut idx = 0;
|
||||
for el in seq.iter().unwrap() {
|
||||
assert_eq!(v[idx], el.unwrap().extract::<i32>().unwrap());
|
||||
|
@ -393,7 +393,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = vec!["It", "was", "the", "worst", "of", "times"];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
|
||||
let bad_needle = "blurst".to_object(py);
|
||||
assert_eq!(false, seq.contains(bad_needle).unwrap());
|
||||
|
@ -407,7 +407,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v : Vec<i32> = vec![1, 2, 3];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let concat_seq = seq.concat(&seq).unwrap();
|
||||
assert_eq!(6, concat_seq.len().unwrap());
|
||||
let concat_v : Vec<i32> = vec![1, 2, 3, 1, 2, 3];
|
||||
|
@ -421,7 +421,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = "string";
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let concat_seq = seq.concat(&seq).unwrap();
|
||||
assert_eq!(12, concat_seq.len().unwrap());
|
||||
/*let concat_v = "stringstring".to_owned();
|
||||
|
@ -435,7 +435,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = vec!["foo", "bar"];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let repeat_seq = seq.repeat(3).unwrap();
|
||||
assert_eq!(6, repeat_seq.len().unwrap());
|
||||
let repeated = vec!["foo", "bar", "foo", "bar", "foo", "bar"];
|
||||
|
@ -449,7 +449,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = vec!["foo", "bar"];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
assert!(seq.list().is_ok());
|
||||
}
|
||||
|
||||
|
@ -467,7 +467,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = ("foo", "bar");
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
assert!(seq.tuple().is_ok());
|
||||
}
|
||||
|
||||
|
@ -476,7 +476,7 @@ mod test {
|
|||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
let v = vec!["foo", "bar"];
|
||||
let seq = v.to_object(py).into_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
let seq = v.to_object(py).cast_into::<PySequence>(py).unwrap();
|
||||
assert!(seq.tuple().is_ok());
|
||||
}
|
||||
|
||||
|
|
|
@ -3,14 +3,13 @@
|
|||
|
||||
use std::{hash, collections};
|
||||
use ffi;
|
||||
use pointers::PyPtr;
|
||||
use pyptr;
|
||||
use python::{Python, ToPythonPointer};
|
||||
use conversion::ToPyObject;
|
||||
use objects::{PyObject, PyIterator};
|
||||
use objects::PyObject;
|
||||
use err::{self, PyResult, PyErr};
|
||||
use pyptr;
|
||||
use token::{PyObjectMarker, PythonObjectWithGilToken};
|
||||
use objectprotocol::ObjectProtocol;
|
||||
use native::PyNativeObject;
|
||||
use token::{PythonObjectWithGilToken};
|
||||
|
||||
|
||||
/// Represents a Python `set`
|
||||
|
@ -80,34 +79,29 @@ impl<'p> PySet<'p> {
|
|||
ffi::PySet_Pop(self.as_ptr()))
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn iter(&self) -> PyResult<PyIterator<'p>> {
|
||||
Ok(self.to_object(self.gil()).into_object(self.gil()).iter()?)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> ToPyObject for collections::HashSet<T>
|
||||
where T: hash::Hash + Eq + ToPyObject
|
||||
{
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
let set = PySet::new::<T>(py, &[]);
|
||||
for val in self {
|
||||
set.add(val).unwrap();
|
||||
}
|
||||
set.to_object(py)
|
||||
set.as_object()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> ToPyObject for collections::BTreeSet<T>
|
||||
where T: hash::Hash + Eq + ToPyObject
|
||||
{
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
let set = PySet::new::<T>(py, &[]);
|
||||
for val in self {
|
||||
set.add(val).unwrap();
|
||||
}
|
||||
set.to_object(py)
|
||||
set.as_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -141,18 +135,15 @@ impl<'p> PyFrozenSet<'p> {
|
|||
}
|
||||
})
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn iter(&self) -> PyResult<PyIterator<'p>> {
|
||||
Ok(self.to_object(self.gil()).into_object(self.gil()).iter()?)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use std::collections::{HashSet};
|
||||
use python::{Python, PyDowncastFrom};
|
||||
use python::{Python, PyDowncastInto};
|
||||
use native::PyNativeObject;
|
||||
use conversion::ToPyObject;
|
||||
use objectprotocol::ObjectProtocol;
|
||||
use super::{PySet, PyFrozenSet};
|
||||
|
||||
#[test]
|
||||
|
@ -171,11 +162,11 @@ mod test {
|
|||
|
||||
let mut v = HashSet::new();
|
||||
let ob = v.to_object(py);
|
||||
let set = PySet::downcast_from(ob.as_object(py)).unwrap();
|
||||
let set = PySet::downcast_into(py, ob.as_object()).unwrap();
|
||||
assert_eq!(0, set.len());
|
||||
v.insert(7);
|
||||
let ob = v.to_object(py);
|
||||
let set2 = PySet::downcast_from(ob.as_object(py)).unwrap();
|
||||
let set2 = PySet::downcast_into(py, ob.as_object()).unwrap();
|
||||
assert_eq!(1, set2.len());
|
||||
}
|
||||
|
||||
|
|
|
@ -3,12 +3,13 @@
|
|||
use std::os::raw::c_long;
|
||||
|
||||
use ::pyptr;
|
||||
use pointers::PyPtr;
|
||||
use python::{ToPythonPointer, Python};
|
||||
use err::{PyErr, PyResult};
|
||||
use ffi::{self, Py_ssize_t};
|
||||
use native::PyNativeObject;
|
||||
use objects::PyObject;
|
||||
use conversion::ToPyObject;
|
||||
use token::{PyObjectMarker, PythonObjectWithGilToken};
|
||||
use token::PythonObjectWithGilToken;
|
||||
|
||||
/// Represents a Python `slice` indices
|
||||
pub struct PySliceIndices {
|
||||
|
@ -78,7 +79,7 @@ impl<'p> PySlice<'p> {
|
|||
}
|
||||
|
||||
impl ToPyObject for PySliceIndices {
|
||||
fn to_object<'p>(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
PySlice::new(py, self.start, self.stop, self.step).to_object(py)
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PySlice::new(py, self.start, self.stop, self.step).as_object()
|
||||
}
|
||||
}
|
||||
|
|
|
@ -8,12 +8,13 @@ use std::ascii::AsciiExt;
|
|||
use std::borrow::Cow;
|
||||
use std::os::raw::c_char;
|
||||
|
||||
use ::{PyPtr, pyptr};
|
||||
use ffi;
|
||||
use pyptr;
|
||||
use python::{ToPythonPointer, Python};
|
||||
use super::{exc, PyObject};
|
||||
use token::{PyObjectMarker, PythonObjectWithGilToken};
|
||||
use token::PythonObjectWithGilToken;
|
||||
use err::{PyResult, PyErr};
|
||||
use native::PyNativeObject;
|
||||
use conversion::{ToPyObject, RefFromPyObject};
|
||||
|
||||
/// Represents a Python string.
|
||||
|
@ -220,8 +221,8 @@ impl<'p> PyBytes<'p> {
|
|||
/// See `PyString::new` for details on the conversion.
|
||||
impl ToPyObject for str {
|
||||
#[inline]
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
PyString::new(py, self).to_object(py)
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyString::new(py, self).as_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -229,8 +230,8 @@ impl ToPyObject for str {
|
|||
/// See `PyString::new` for details on the conversion.
|
||||
impl <'a> ToPyObject for Cow<'a, str> {
|
||||
#[inline]
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
PyString::new(py, self).to_object(py)
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyString::new(py, self).as_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -238,8 +239,8 @@ impl <'a> ToPyObject for Cow<'a, str> {
|
|||
/// See `PyString::new` for details on the conversion.
|
||||
impl ToPyObject for String {
|
||||
#[inline]
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
PyString::new(py, self).to_object(py)
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyString::new(py, self).as_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -271,6 +272,7 @@ impl<'p> RefFromPyObject<'p> for str {
|
|||
#[cfg(test)]
|
||||
mod test {
|
||||
use python::Python;
|
||||
use native::PyNativeObject;
|
||||
use conversion::{ToPyObject, RefFromPyObject};
|
||||
|
||||
#[test]
|
||||
|
@ -279,7 +281,7 @@ mod test {
|
|||
let py = gil.python();
|
||||
let s = "\u{1F30F}";
|
||||
let py_string = s.to_object(py);
|
||||
assert_eq!(s, py_string.as_object(py).extract::<String>().unwrap());
|
||||
assert_eq!(s, py_string.as_object().extract::<String>().unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
@ -289,7 +291,7 @@ mod test {
|
|||
let s = "Hello Python";
|
||||
let py_string = s.to_object(py);
|
||||
let mut called = false;
|
||||
RefFromPyObject::with_extracted(&py_string.as_object(py),
|
||||
RefFromPyObject::with_extracted(&py_string.as_object(),
|
||||
|s2: &str| {
|
||||
assert_eq!(s, s2);
|
||||
called = true;
|
||||
|
|
|
@ -4,13 +4,14 @@
|
|||
|
||||
use std::slice;
|
||||
|
||||
use ::{PyPtr, pyptr};
|
||||
use pyptr;
|
||||
use ffi::{self, Py_ssize_t};
|
||||
use err::{PyErr, PyResult};
|
||||
use python::{Python, ToPythonPointer, IntoPythonPointer};
|
||||
use conversion::{FromPyObject, ToPyObject, ToPyTuple, IntoPyObject};
|
||||
use objects::PyObject;
|
||||
use token::{PyObjectMarker, PythonObjectWithGilToken};
|
||||
use native::PyNativeObject;
|
||||
use token::PythonObjectWithGilToken;
|
||||
use super::exc;
|
||||
|
||||
/// Represents a Python tuple object.
|
||||
|
@ -108,10 +109,10 @@ fn wrong_tuple_length(py: Python, t: &PyTuple, expected_length: usize) -> PyErr
|
|||
|
||||
macro_rules! tuple_conversion ({$length:expr,$(($refN:ident, $n:tt, $T:ident)),+} => {
|
||||
impl <$($T: ToPyObject),+> ToPyObject for ($($T,)+) {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyPtr<PyObjectMarker> {
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyTuple::new(py, &[
|
||||
$(py_coerce_expr!(self.$n.to_object(py)),)+
|
||||
]).to_object(py)
|
||||
]).as_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -125,7 +126,6 @@ macro_rules! tuple_conversion ({$length:expr,$(($refN:ident, $n:tt, $T:ident)),+
|
|||
|
||||
impl<'s, $($T: FromPyObject<'s>),+> FromPyObject<'s> for ($($T,)+) {
|
||||
fn extract(obj: &'s PyObject<'s>) -> PyResult<Self>
|
||||
//where S: ::typeob::PyTypeInfo
|
||||
{
|
||||
let t = try!(obj.cast_as::<PyTuple>());
|
||||
let slice = t.as_slice();
|
||||
|
@ -174,8 +174,8 @@ pub struct NoArgs;
|
|||
/// Converts `NoArgs` to an empty Python tuple.
|
||||
impl ToPyObject for NoArgs {
|
||||
|
||||
fn to_object(&self, py: Python) -> PyPtr<PyObjectMarker> {
|
||||
PyTuple::empty(py).to_object(py)
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyTuple::empty(py).as_object()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -10,7 +10,7 @@ use err::{PyErr, PyResult, PyDowncastError};
|
|||
use conversion::{ToPyObject, IntoPyObject};
|
||||
use objects::PyObject;
|
||||
use python::{Python, ToPythonPointer, IntoPythonPointer};
|
||||
use token::{PyObjectMarker, PythonObjectWithGilToken};
|
||||
use token::PythonObjectWithGilToken;
|
||||
use typeob::{PyTypeInfo, PyObjectAlloc};
|
||||
|
||||
|
||||
|
@ -123,13 +123,6 @@ impl pptr {
|
|||
unsafe { std::mem::transmute(self) }
|
||||
}
|
||||
|
||||
/// Converts `pptr` instance -> PyObject<'p>
|
||||
/// Consumes `self` without calling `Py_DECREF()`
|
||||
#[inline]
|
||||
pub fn into_pobject(self) -> PyPtr<PyObjectMarker> {
|
||||
unsafe { std::mem::transmute(self) }
|
||||
}
|
||||
|
||||
/// Clone self, Calls Py_INCREF() on the ptr.
|
||||
#[inline]
|
||||
pub fn clone_ref(&self, _py: Python) -> pptr {
|
||||
|
@ -503,15 +496,6 @@ impl<'p, T> Py<'p, T>
|
|||
ptr
|
||||
}
|
||||
|
||||
/// Converts Py<'p, T> -> Py<'p, PyObject>
|
||||
/// Consumes `self` without calling `Py_DECREF()`
|
||||
#[inline]
|
||||
pub fn into_object(self) -> Py<'p, PyObjectMarker> {
|
||||
let p = Py {inner: self.inner, _t: PhantomData, py: self.py};
|
||||
std::mem::forget(self);
|
||||
p
|
||||
}
|
||||
|
||||
/// Converts Py<'p, T> -> PyObject<'p>. Calls Py_INCREF() on the ptr.
|
||||
#[inline]
|
||||
pub fn as_pyobject(&self) -> &PyObject<'p> {
|
||||
|
@ -801,8 +785,8 @@ impl<'source, T> ::FromPyObject<'source> for Py<'source, T> where T: PyTypeInfo
|
|||
impl <'a, T> ToPyObject for Py<'a, T> {
|
||||
|
||||
#[inline]
|
||||
default fn to_object<'p>(&self, _py: Python) -> PyPtr<PyObjectMarker> {
|
||||
unsafe { PyPtr::from_borrowed_ptr(self.inner) }
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyObject::from_borrowed_ptr(py, self.inner)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
@ -816,8 +800,8 @@ impl <'a, T> ToPyObject for Py<'a, T> {
|
|||
impl<T> ToPyObject for PyPtr<T> {
|
||||
|
||||
#[inline]
|
||||
default fn to_object(&self, _py: Python) -> PyPtr<PyObjectMarker> {
|
||||
unsafe { PyPtr::from_borrowed_ptr(self.inner) }
|
||||
fn to_object<'p>(&self, py: Python<'p>) -> PyObject<'p> {
|
||||
PyObject::from_borrowed_ptr(py, self.inner)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
|
63
src/token.rs
63
src/token.rs
|
@ -1,13 +1,9 @@
|
|||
// Copyright (c) 2017-present PyO3 Project and Contributors
|
||||
|
||||
use std::fmt;
|
||||
use std::marker::PhantomData;
|
||||
|
||||
use ffi;
|
||||
use pointers::{Py, PyPtr};
|
||||
use err::{PyResult};
|
||||
use python::{Python, ToPythonPointer, PyDowncastInto};
|
||||
use objects::PyString;
|
||||
use pointers::Py;
|
||||
use python::Python;
|
||||
use typeob::{PyTypeInfo, PyObjectAlloc};
|
||||
|
||||
|
||||
|
@ -40,58 +36,3 @@ pub trait PythonObjectWithGilToken<'p> : Sized {
|
|||
pub trait PythonObjectWithToken : Sized {
|
||||
fn token<'p>(&'p self) -> Python<'p>;
|
||||
}
|
||||
|
||||
pub struct PyObjectMarker;
|
||||
|
||||
|
||||
impl PyObjectMarker {
|
||||
|
||||
#[inline]
|
||||
pub fn from_owned_ptr(_py: Python, ptr: *mut ffi::PyObject) -> PyPtr<PyObjectMarker> {
|
||||
unsafe { PyPtr::from_owned_ptr(ptr) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_owned_ptr_or_err(py: Python, ptr: *mut ffi::PyObject)
|
||||
-> PyResult<PyPtr<PyObjectMarker>> {
|
||||
unsafe { PyPtr::from_owned_ptr_or_err(py, ptr) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_owned_ptr_or_opt(py: Python, ptr: *mut ffi::PyObject)
|
||||
-> Option<PyPtr<PyObjectMarker>> {
|
||||
unsafe { PyPtr::from_owned_ptr_or_opt(py, ptr) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn from_borrowed_ptr(_py: Python, ptr: *mut ffi::PyObject) -> PyPtr<PyObjectMarker> {
|
||||
unsafe { PyPtr::from_borrowed_ptr(ptr) }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
impl<'p> fmt::Debug for PyPtr<PyObjectMarker> {
|
||||
default fn fmt(&self, f : &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
||||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
|
||||
let repr_obj = unsafe {
|
||||
PyString::downcast_from_owned_ptr(py, ffi::PyObject_Repr(self.as_ptr()))
|
||||
.map_err(|_| fmt::Error)?
|
||||
};
|
||||
f.write_str(&repr_obj.to_string_lossy())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'p> fmt::Display for PyPtr<PyObjectMarker> {
|
||||
default fn fmt(&self, f : &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
||||
let gil = Python::acquire_gil();
|
||||
let py = gil.python();
|
||||
|
||||
let str_obj = unsafe {
|
||||
PyString::downcast_from_owned_ptr(py, ffi::PyObject_Str(self.as_ptr()))
|
||||
.map_err(|_| fmt::Error)?
|
||||
};
|
||||
f.write_str(&str_obj.to_string_lossy())
|
||||
}
|
||||
}
|
||||
|
|
|
@ -26,16 +26,16 @@ struct Test {}
|
|||
#[py::proto]
|
||||
impl<'p> PyMappingProtocol<'p> for Test
|
||||
{
|
||||
fn __getitem__(&self, py: Python, idx: PyObject<'p>) -> PyResult<PyPtr<PyObjectMarker>> {
|
||||
fn __getitem__(&self, py: Python, idx: PyObject<'p>) -> PyResult<pptr> {
|
||||
if let Ok(slice) = idx.cast_as::<PySlice>() {
|
||||
let indices = slice.indices(1000)?;
|
||||
if indices.start == 100 && indices.stop == 200 && indices.step == 1 {
|
||||
return Ok("slice".to_object(py))
|
||||
return Ok("slice".into_object(py))
|
||||
}
|
||||
}
|
||||
else if let Ok(idx) = idx.extract::<isize>() {
|
||||
if idx == 1 {
|
||||
return Ok("int".to_object(py))
|
||||
return Ok("int".into_object(py))
|
||||
}
|
||||
}
|
||||
Err(PyErr::new::<exc::ValueError, _>(py, "error"))
|
||||
|
|
Loading…
Reference in New Issue