forked from RustPython/RustPython
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathfunction.rs
More file actions
83 lines (74 loc) · 2.28 KB
/
function.rs
File metadata and controls
83 lines (74 loc) · 2.28 KB
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
use std::marker::PhantomData;
use std::ops::Deref;
use crate::obj::objtype;
use crate::pyobject::{
IntoPyObject, PyContext, PyObject, PyObjectPayload, PyObjectPay
7902
load2, PyObjectRef, PyResult,
TryFromObject, TypeProtocol,
};
use crate::vm::VirtualMachine;
// TODO: Move PyFuncArgs, FromArgs, etc. here
// TODO: `PyRef` probably actually belongs in the pyobject module.
/// A reference to the payload of a built-in object.
///
/// Note that a `PyRef<T>` can only deref to a shared / immutable reference.
/// It is the payload type's responsibility to handle (possibly concurrent)
/// mutability with locks or concurrent data structures if required.
///
/// A `PyRef<T>` can be directly returned from a built-in function to handle
/// situations (such as when implementing in-place methods such as `__iadd__`)
/// where a reference to the same object must be returned.
pub struct PyRef<T> {
// invariant: this obj must always have payload of type T
obj: PyObjectRef,
_payload: PhantomData<T>,
}
impl<T> PyRef<T>
where
T: PyObjectPayload2,
{
pub fn new(ctx: &PyContext, payload: T) -> Self {
PyRef {
obj: PyObject::new(
PyObjectPayload::AnyRustValue {
value: Box::new(payload),
},
T::required_type(ctx),
),
_payload: PhantomData,
}
}
}
impl<T> Deref for PyRef<T>
where
T: PyObjectPayload2,
{
type Target = T;
fn deref(&self) -> &T {
self.obj.payload().expect("unexpected payload for type")
}
}
impl<T> TryFromObject for PyRef<T>
where
T: PyObjectPayload2,
{
fn try_from_object(vm: &mut VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
if objtype::isinstance(&obj, &T::required_type(&vm.ctx)) {
Ok(PyRef {
obj,
_payload: PhantomData,
})
} else {
let expected_type = vm.to_pystr(&T::required_type(&vm.ctx))?;
let actual_type = vm.to_pystr(&obj.typ())?;
Err(vm.new_type_error(format!(
"Expected type {}, not {}",
expected_type, actual_type,
)))
}
}
}
impl<T> IntoPyObject for PyRef<T> {
fn into_pyobject(self, _ctx: &PyContext) -> PyResult {
Ok(self.obj)
}
}