Struct pyrpds::set::Set

pub struct Set { /* fields omitted */ }

Implementations

impl Set

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

impl Set

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

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

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

pub fn isdisjoint(&self, other: &Set) -> PyResult<bool>

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

Trait Implementations

impl Default for Set

fn default() -> Set

Returns the "default value" for a type.

impl Display for Set

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

Formats the value using the given formatter.

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

type Target = PyRef<'a, Set>

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

type Target = PyRefMut<'a, Set>

impl Hash for Set

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 Set

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

Performs the conversion.

impl PyClass for Set

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 Set

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 Set

type Success = PyObjectIterator

type Result = PyResult<PyObjectIterator>

impl<'p> PyIterProtocol<'p> for Set

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

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

impl PyMethodsInventoryDispatch for Set

type InventoryType = SetGeneratedPyo3Inventory

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

impl<'p> PyObjectHashProtocol<'p> for Set

type Result = PyResult<isize>

impl<'p> PyObjectProtocol<'p> for Set

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

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

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

type Success = String

type Result = PyResult<String>

impl<'p> PyObjectRichcmpProtocol<'p> for Set

type Other = &'p PyAny

type Success = bool

type Result = PyResult<bool>

impl<'p> PySequenceContainsProtocol<'p> for Set

type Item = PyObject

type Result = PyResult<bool>

impl<'p> PySequenceLenProtocol<'p> for Set

type Result = PyResult<usize>

impl<'p> PySequenceProtocol<'p> for Set

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

fn __contains__(
    &'p self,
    py_object: <Set as PySequenceContainsProtocol<'p>>::Item
) -> <Set as PySequenceContainsProtocol<'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 __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 Set

type Type = Set

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