Struct librsnek::api::rtobject::RtObject

pub struct RtObject(StrongRc<Type>);

The wrapper and interface around any rust native structure

Methods

impl RtObject

fn new(value: Type) -> RtObject

fn downgrade(&self) -> WeakRtObject

Downgrade the RtObject to a WeakRtObject

fn strong_count(&self) -> Integer

fn weak_count(&self) -> Integer

fn id(&self) -> ObjectId

fn debug_name(&self) -> &str

fn to_string(&self) -> String

Trait Implementations

impl Serialize for RtObject

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl PartialEq for RtObject

fn eq(&self, rhs: &RtObject) -> bool

This method tests for self and other values to be equal, and is used

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Eq for RtObject

fn assert_receiver_is_total_eq(&self)

impl Clone for RtObject

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Hash for RtObject

fn hash<H: Hasher>(&self, s: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Display for RtObject

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Debug for RtObject

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl AsRef<Type> for RtObject

fn as_ref(&self) -> &Type

Performs the conversion.

impl Iterator for RtObject

While it is cool to be able to directly iterate over an RtObject

type Item = RtObject

The type of the elements being iterated over.

fn next(&mut self) -> Option<Self::Item>

Advances the iterator and returns the next value.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

Consumes the iterator, returning the last element.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator<Item = Self::Item>, 

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator, 

'Zips up' two iterators into a single iterator of pairs.

fn map<B, F>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Item) -> B, 

Takes a closure and creates an iterator which calls that closure on each

fn filter<P>(self, predicate: P) -> Filter<Self, P> where
    P: FnMut(&Self::Item) -> bool, 

Creates an iterator which uses a closure to determine if an element

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    F: FnMut(Self::Item) -> Option<B>, 

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

Creates an iterator which gives the current iteration count as well as

fn peekable(self) -> Peekable<Self>

Creates an iterator which can use peek to look at the next element of

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool, 

Creates an iterator that [skip]s elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool, 

Creates an iterator that yields elements based on a predicate.

fn skip(self, n: usize) -> Skip<Self>

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

Creates an iterator that yields its first n elements.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
    F: FnMut(&mut St, Self::Item) -> Option<B>, 

An iterator adaptor similar to [fold] that holds internal state and

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    F: FnMut(Self::Item) -> U,
    U: IntoIterator, 

Creates an iterator that works like map, but flattens nested structure.

fn fuse(self) -> Fuse<Self>

Creates an iterator which ends after the first [None].

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnMut(&Self::Item) -> (), 

Do something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

Borrows an iterator, rather than consuming it.

fn collect<B>(self) -> B where
    B: FromIterator<Self::Item>, 

Transforms an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B) where
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool, 

Consumes an iterator, creating two collections from it.

fn fold<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, Self::Item) -> B, 

An iterator adaptor that applies a function, producing a single, final value.

fn all<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool, 

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool, 

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

Searches for an element of an iterator that satisfies a predicate.

fn position<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool, 

Searches for an element in an iterator, returning its index.

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool,
    Self: ExactSizeIterator + DoubleEndedIterator, 

Searches for an element in an iterator from the right, returning its

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the maximum value from the

fn max_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the maximum value with respect to the

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the minimum value from the

fn min_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the minimum value with respect to the

fn rev(self) -> Rev<Self> where
    Self: DoubleEndedIterator, 

Reverses an iterator's direction.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Iterator<Item = (A, B)>, 

Converts an iterator of pairs into a pair of containers.

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: Iterator<Item = &'a T>,
    T: 'a + Clone, 

Creates an iterator which [clone]s all of its elements.

fn cycle(self) -> Cycle<Self> where
    Self: Clone, 

Repeats an iterator endlessly.

fn sum<S>(self) -> S where
    S: Sum<Self::Item>, 

Sums the elements of an iterator.

fn product<P>(self) -> P where
    P: Product<Self::Item>, 

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord, 

Lexicographically compares the elements of this Iterator with those

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Lexicographically compares the elements of this Iterator with those

fn eq<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are equal to those of

fn ne<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are unequal to those of

fn lt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically

fn le<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically

fn gt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically

fn ge<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically

impl PyAPI for RtObject

impl GetAttr for RtObject

fn op_getattr(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_getattr(&self, name: &Type) -> Result<RtObject, Error>

Native API Method $pyname

impl SetAttr for RtObject

fn op_setattr(
    &self,
    rt: &Runtime,
    name: &RtObject,
    value: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_setattr(&self, name: &Type, value: &Type) -> Result<None, Error>

Native API Method $pyname

impl Id for RtObject

fn op_id(&self, rt: &Runtime) -> Result<RtObject, Error>

fn native_id(&self) -> ObjectId

impl Is for RtObject

fn op_is(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

fn native_is(&self, rhs: &Type) -> Result<Boolean, Error>

impl IsNot for RtObject

fn op_is_not(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

fn native_is_not(&self, rhs: &Type) -> Result<Boolean, Error>

impl Hashed for RtObject

fn op_hash(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_hash(&self) -> Result<HashId, Error>

Native API Method $pyname

impl StringCast for RtObject

fn op_str(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_str(&self) -> Result<String, Error>

Native API Method $pyname

impl BytesCast for RtObject

fn op_bytes(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_bytes(&self) -> Result<Bytes, Error>

Native API Method $pyname

impl StringFormat for RtObject

fn op_format(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_format(&self) -> Result<String, Error>

Native API Method $pyname

impl StringRepresentation for RtObject

fn op_repr(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_repr(&self) -> Result<String, Error>

Native API Method $pyname

impl Equal for RtObject

fn op_eq(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Default implementation of equals fallsbacks to op_is.

fn native_eq(&self, rhs: &Type) -> Result<Boolean, Error>

Default implementation of equals fallsbacks to op_is.

impl NotEqual for RtObject

fn op_ne(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Default implementation of equals fallsbacks to !op_is

fn native_ne(&self, rhs: &Type) -> Result<Boolean, Error>

Default implementation of equals fallsbacks to op_is.

impl LessThan for RtObject

fn op_lt(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_lt(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl LessOrEqual for RtObject

fn op_le(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_le(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl GreaterOrEqual for RtObject

fn op_ge(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ge(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl GreaterThan for RtObject

fn op_gt(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_gt(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl BooleanCast for RtObject

fn op_bool(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_bool(&self) -> Result<Boolean, Error>

Native API Method $pyname

impl IntegerCast for RtObject

fn op_int(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_int(&self) -> Result<Integer, Error>

Native API Method $pyname

impl FloatCast for RtObject

fn op_float(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_float(&self) -> Result<Float, Error>

Native API Method $pyname

impl ComplexCast for RtObject

fn op_complex(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_complex(&self) -> Result<Complex, Error>

Native API Method $pyname

impl Index for RtObject

fn op_index(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_index(&self) -> Result<Integer, Error>

Native API Method $pyname

impl NegateValue for RtObject

fn op_neg(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_neg(&self) -> Result<Number, Error>

Native API Method $pyname

impl AbsValue for RtObject

fn op_abs(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_abs(&self) -> Result<Number, Error>

Native API Method $pyname

impl PositiveValue for RtObject

fn op_pos(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_pos(&self) -> Result<Number, Error>

Native API Method $pyname

impl InvertValue for RtObject

fn op_invert(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_invert(&self) -> Result<Number, Error>

Native API Method $pyname

impl Add for RtObject

fn op_add(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_add(&self, rhs: &Type) -> Result<Native, Error>

Native API Method $pyname

impl BitwiseAnd for RtObject

fn op_and(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_and(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl DivMod for RtObject

fn op_divmod(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_divmod(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl FloorDivision for RtObject

fn op_floordiv(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_floordiv(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl LeftShift for RtObject

fn op_lshift(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_lshift(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Modulus for RtObject

fn op_mod(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_mod(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Multiply for RtObject

fn op_mul(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_mul(&self, rhs: &Type) -> Result<Native, Error>

Native API Method $pyname

impl MatrixMultiply for RtObject

fn op_matmul(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_matmul(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl BitwiseOr for RtObject

fn op_or(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_or(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Pow for RtObject

fn op_pow(
    &self,
    rt: &Runtime,
    power: &RtObject,
    modulus: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_pow(&self, power: &Type, modulus: &Type) -> Result<Type, Error>

Native API Method $pyname

impl RightShift for RtObject

fn op_rshift(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rshift(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Subtract for RtObject

fn op_sub(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_sub(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl TrueDivision for RtObject

fn op_truediv(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_truediv(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl XOr for RtObject

fn op_xor(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_xor(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceAdd for RtObject

fn op_iadd(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_iadd(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceBitwiseAnd for RtObject

fn op_iand(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_iand(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceDivMod for RtObject

fn op_idivmod(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_idivmod(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceFloorDivision for RtObject

fn op_ifloordiv(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ifloordiv(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceLeftShift for RtObject

fn op_ilshift(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ilshift(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceModulus for RtObject

fn op_imod(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_imod(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceMultiply for RtObject

fn op_imul(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_imul(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceMatrixMultiply for RtObject

fn op_imatmul(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_imatmul(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceBitwiseOr for RtObject

fn op_ior(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ior(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlacePow for RtObject

fn op_ipow(
    &self,
    rt: &Runtime,
    power: &RtObject,
    modulus: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ipow(&self, power: &Type, modulus: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceRightShift for RtObject

fn op_irshift(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_irshift(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceSubtract for RtObject

fn op_isub(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_isub(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceTrueDivision for RtObject

fn op_itruediv(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_itruediv(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceXOr for RtObject

fn op_ixor(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ixor(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Contains for RtObject

fn op_contains(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_contains(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl Iter for RtObject

fn op_iter(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_iter(&self) -> Result<Iterator, Error>

Native API Method $pyname

impl Call for RtObject

fn op_call(
    &self,
    rt: &Runtime,
    pos_args: &RtObject,
    starargs: &RtObject,
    kwargs: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_call(
    &self,
    pos_args: &Type,
    starargs: &Type,
    kwargs: &Type
) -> Result<Type, Error>

Native API Method $pyname

impl Length for RtObject

fn op_len(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_len(&self) -> Result<Integer, Error>

Native API Method $pyname

impl Next for RtObject

fn op_next(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_next(&self) -> Result<RtObject, Error>

Native API Method $pyname

impl GetItem for RtObject

fn op_getitem(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_getitem(&self, name: &Type) -> Result<RtObject, Error>

Native API Method $pyname

impl SetItem for RtObject

fn op_setitem(
    &self,
    rt: &Runtime,
    name: &RtObject,
    item: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_setitem(&self, name: &Type, item: &Type) -> Result<None, Error>

Native API Method $pyname

impl DeleteItem for RtObject

fn op_delitem(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_delitem(&self, name: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Count for RtObject

fn meth_count(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_count(&self, name: &Type) -> Result<Integer, Error>

Native API Method $pyname

impl Append for RtObject

fn meth_append(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_append(&self, name: &Type) -> Result<None, Error>

Native API Method $pyname

impl Extend for RtObject

fn meth_extend(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_extend(&self, name: &Type) -> Result<None, Error>

Native API Method $pyname

impl Pop for RtObject

fn meth_pop(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_pop(&self, name: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Remove for RtObject

fn meth_remove(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_remove(&self, name: &Type) -> Result<Type, Error>

Native API Method $pyname

impl IsDisjoint for RtObject

fn meth_isdisjoint(
    &self,
    rt: &Runtime,
    name: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_isdisjoint(&self, name: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl AddItem for RtObject

fn meth_add(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_add(&self, name: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Keys for RtObject

fn meth_keys(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_keys(&self) -> Result<Tuple, Error>

Native API Method $pyname

impl Await for RtObject

fn op_await(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_await(&self) -> Result<Type, Error>

Native API Method $pyname

impl Clear for RtObject

fn meth_clear(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_clear(&self) -> Result<Type, Error>

Native API Method $pyname

impl Close for RtObject

fn meth_close(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_close(&self) -> Result<Type, Error>

Native API Method $pyname

impl DelAttr for RtObject

fn op_delattr(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_delattr(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Delete for RtObject

fn op_del(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_del(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl DescriptorGet for RtObject

fn op_get(&self, &Runtime, &RtObject, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_get(&self, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl DescriptorSet for RtObject

fn op_set(&self, &Runtime, &RtObject, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_set(&self, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl DescriptorSetName for RtObject

fn op_set_name(&self, &Runtime, &RtObject, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_set_name(&self, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Discard for RtObject

fn meth_discard(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_discard(&self) -> Result<Type, Error>

Native API Method $pyname

impl Enter for RtObject

fn op_enter(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_enter(&self) -> Result<Type, Error>

Native API Method $pyname

impl Exit for RtObject

fn op_exit(
    &self,
    &Runtime,
    &RtObject,
    &RtObject,
    &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_exit(&self, &Type, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Get for RtObject

fn meth_get(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_get(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl GetAttribute for RtObject

fn op_getattribute(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_getattribute(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Init for RtObject

fn op_init(
    &mut self,
    rt: &Runtime,
    named_args: &RtObject,
    args: &RtObject,
    kwargs: &RtObject
) -> Result<RtObject, Error>

fn native_init(
    &mut self,
    named_args: &Type,
    args: &Type,
    kwargs: &Type
) -> Result<None, Error>

impl Items for RtObject

fn meth_items(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_items(&self) -> Result<Type, Error>

Native API Method $pyname

impl LengthHint for RtObject

fn op_length_hint(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_length_hint(&self) -> Result<Integer, Error>

Native API Method $pyname

impl New for RtObject

fn op_new(
    &self,
    &Runtime,
    &RtObject,
    &RtObject,
    &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_new(&self, &Type, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl PopItem for RtObject

fn meth_popitem(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_popitem(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedAdd for RtObject

fn op_radd(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_radd(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedBitwiseAnd for RtObject

fn op_rand(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rand(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedBitwiseOr for RtObject

fn op_ror(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ror(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedDivMod for RtObject

fn op_rdivmod(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rdivmod(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedFloorDivision for RtObject

fn op_rfloordiv(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rfloordiv(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedLeftShift for RtObject

fn op_rlshift(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rlshift(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedMatrixMultiply for RtObject

fn op_rmatmul(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rmatmul(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedModulus for RtObject

fn op_rmod(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rmod(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedMultiply for RtObject

fn op_rmul(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rmul(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedPow for RtObject

fn op_rpow(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rpow(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedRightShift for RtObject

fn op_rrshift(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rrshift(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedSubtract for RtObject

fn op_rsub(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rsub(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedTrueDivision for RtObject

fn op_rtruediv(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rtruediv(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedXOr for RtObject

fn op_rxor(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rxor(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Reversed for RtObject

fn op_reversed(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_reversed(&self) -> Result<Type, Error>

Native API Method $pyname

impl Rounding for RtObject

fn op_round(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_round(&self) -> Result<Number, Error>

Native API Method $pyname

impl Send for RtObject

fn meth_send(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_send(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl SetDefault for RtObject

fn meth_setdefault(
    &self,
    &Runtime,
    &RtObject,
    &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_setdefault(&self, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Throw for RtObject

fn meth_throw(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_throw(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Update for RtObject

fn meth_update(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_update(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Values for RtObject

fn meth_values(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_values(&self) -> Result<Type, Error>

Native API Method $pyname