Struct pyrpds::vector::Vector

pub struct Vector { /* fields omitted */ }

Implementations

impl Vector

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

impl Vector

pub fn set(&self, index: isize, py_object: PyObject) -> PyResult<Self>

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

pub fn extend(&self, iterator: PyObject) -> PyResult<Self>

pub fn get(&self, index: isize) -> PyResult<PyObject>

pub fn index(&self, py_object: PyObject) -> PyResult<usize>

pub fn count(&self, py_object: PyObject) -> PyResult<usize>

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

pub fn mset(&self, args: &PyTuple) -> PyResult<Vector>

Trait Implementations

impl Default for Vector

fn default() -> Vector

Returns the "default value" for a type.

impl Display for Vector

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

Formats the value using the given formatter.

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

type Target = PyRef<'a, Vector>

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

type Target = PyRefMut<'a, Vector>

impl Hash for Vector

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 Vector

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

Performs the conversion.

impl PyClass for Vector

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 Vector

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 Vector

type Success = PyObjectIterator

type Result = PyResult<PyObjectIterator>

impl<'p> PyIterProtocol<'p> for Vector

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

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

impl PyMethodsInventoryDispatch for Vector

type InventoryType = VectorGeneratedPyo3Inventory

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

impl<'p> PyObjectHashProtocol<'p> for Vector

type Result = PyResult<isize>

impl<'p> PyObjectProtocol<'p> for Vector

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

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

fn __repr__(&'p self) -> <Vector 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 Vector

type Success = String

type Result = PyResult<String>

impl<'p> PyObjectRichcmpProtocol<'p> for Vector

type Other = &'p PyAny

type Success = bool

type Result = PyResult<bool>

impl<'p> PySequenceGetItemProtocol<'p> for Vector

type Index = isize

type Success = PyObject

type Result = PyResult<PyObject>

impl<'p> PySequenceLenProtocol<'p> for Vector

type Result = PyResult<usize>

impl<'p> PySequenceProtocol<'p> for Vector

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

fn __getitem__(
    &'p self,
    index: <Vector as PySequenceGetItemProtocol<'p>>::Index
) -> <Vector as PySequenceGetItemProtocol<'p>>::Result

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 Vector

type Type = Vector

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