Struct pyrpds::list::List

pub struct List { /* fields omitted */ }

Implementations

impl List

#[must_use]pub fn new() -> Self

impl List

pub fn push_front(&self, py_object: PyObject) -> PyResult<Self>

pub fn reverse(&self) -> PyResult<Self>

pub fn first(&self) -> PyResult<PyObject>

Trait Implementations

impl Default for List

fn default() -> List

Returns the "default value" for a type.

impl Display for List

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

Formats the value using the given formatter.

impl<'a> ExtractExt<'a> for &'a List

type Target = PyRef<'a, List>

impl<'a> ExtractExt<'a> for &'a mut List

type Target = PyRefMut<'a, List>

impl Hash for List

fn hash<H: Hasher>(&self, state: &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 IntoPy<PyObject> for List

fn into_py(self, py: Python) -> PyObject

Performs the conversion.

impl PyClass for List

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it's PyDict.

impl PyClassAlloc for List

unsafe fn alloc(_py: Python) -> *mut Self::Layout

Allocate the actual field for #[pyclass].

unsafe fn dealloc(py: Python, self_: *mut Self::Layout)

Deallocate #[pyclass] on the Python heap.

impl<'p> PyIterIterProtocol<'p> for List

type Success = PyObjectIterator

type Result = PyResult<PyObjectIterator>

impl<'p> PyIterProtocol<'p> for List

fn __iter__(slf: PyRefMut<Self>) -> <List as PyIterIterProtocol<'p>>::Result

fn __next__(slf: PyRefMut<Self>) -> Self::Result where
    Self: PyIterNextProtocol<'p>, 

impl PyMethodsInventoryDispatch for List

type InventoryType = ListGeneratedPyo3Inventory

This allows us to get the inventory type when only the pyclass is in scope

impl<'p> PyObjectHashProtocol<'p> for List

type Result = PyResult<isize>

impl<'p> PyObjectProtocol<'p> for List

fn __hash__(&'p self) -> <List as PyObjectHashProtocol<'p>>::Result

fn __richcmp__(
    &'p self,
    other: <List as PyObjectRichcmpProtocol<'p>>::Other,
    op: CompareOp
) -> <List as PyObjectRichcmpProtocol<'p>>::Result

fn __repr__(&'p self) -> <List as PyObjectReprProtocol<'p>>::Result

fn __getattr__(&'p self, name: Self::Name) -> Self::Result where
    Self: PyObjectGetAttrProtocol<'p>, 

fn __setattr__(
    &'p mut self,
    name: Self::Name,
    value: Self::Value
) -> Self::Result where
    Self: PyObjectSetAttrProtocol<'p>, 

fn __delattr__(&'p mut self, name: Self::Name) -> Self::Result where
    Self: PyObjectDelAttrProtocol<'p>, 

fn __str__(&'p self) -> Self::Result where
    Self: PyObjectStrProtocol<'p>, 

fn __format__(&'p self, format_spec: Self::Format) -> Self::Result where
    Self: PyObjectFormatProtocol<'p>, 

fn __bool__(&'p self) -> Self::Result where
    Self: PyObjectBoolProtocol<'p>, 

fn __bytes__(&'p self) -> Self::Result where
    Self: PyObjectBytesProtocol<'p>, 

impl<'p> PyObjectReprProtocol<'p> for List

type Success = String

type Result = PyResult<String>

impl<'p> PyObjectRichcmpProtocol<'p> for List

type Other = &'p PyAny

type Success = bool

type Result = PyResult<bool>

impl<'p> PySequenceLenProtocol<'p> for List

type Result = PyResult<usize>

impl<'p> PySequenceProtocol<'p> for List

fn __len__(&'p self) -> <List as PySequenceLenProtocol<'p>>::Result

fn __getitem__(&'p self, idx: Self::Index) -> Self::Result where
    Self: PySequenceGetItemProtocol<'p>, 

fn __setitem__(
    &'p mut self,
    idx: Self::Index,
    value: Self::Value
) -> Self::Result where
    Self: PySequenceSetItemProtocol<'p>, 

fn __delitem__(&'p mut self, idx: Self::Index) -> Self::Result where
    Self: PySequenceDelItemProtocol<'p>, 

fn __contains__(&'p self, item: Self::Item) -> Self::Result where
    Self: PySequenceContainsProtocol<'p>, 

fn __concat__(&'p self, other: Self::Other) -> Self::Result where
    Self: PySequenceConcatProtocol<'p>, 

fn __repeat__(&'p self, count: Self::Index) -> Self::Result where
    Self: PySequenceRepeatProtocol<'p>, 

fn __inplace_concat__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PySequenceInplaceConcatProtocol<'p>, 

fn __inplace_repeat__(&'p mut self, count: Self::Index) -> Self::Result where
    Self: PySequenceInplaceRepeatProtocol<'p>, 

impl PyTypeInfo for List

type Type = List

Type of objects to store in PyObject struct

type BaseType = PyAny

Base class

type Layout = PyCell<Self>

Layout

type BaseLayout = PyCellBase<PyAny>

Layout of Basetype.

type Initializer = PyClassInitializer<Self>

Initializer for layout

type AsRefTarget = PyCell<Self>

Utility type to make AsPyRef work

const NAME: &'static str

Class name

const MODULE: Option<&'static str>

Module name, if any

const DESCRIPTION: &'static str

Class doc string

const FLAGS: usize

Type flags (ie PY_TYPE_FLAG_GC, PY_TYPE_FLAG_WEAKREF)

fn type_object() -> &'static PyTypeObject

PyTypeObject instance for this type.

fn is_instance(object: &PyAny) -> bool

Check if *mut ffi::PyObject is instance of this type

fn is_exact_instance(object: &PyAny) -> bool

Check if *mut ffi::PyObject is exact instance of this type