Struct nanoset_py::NanoSet

pub struct NanoSet { /* fields omitted */ }

A set that has lower memory footprint if it is empty.

Methods

impl NanoSet

pub fn new() -> Self

pub fn from_set(obj: PyObject) -> Self

pub fn try_from_any(py: Python, any: &PyAny) -> PyResult<Self>

pub fn try_from_obj(py: Python, obj: PyObject) -> PyResult<Self>

pub fn try_from_iterator(py: Python, it: PyIterator) -> PyResult<Self>

Trait Implementations

impl Debug for NanoSet

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

Formats the value using the given formatter.

impl Default for NanoSet

fn default() -> NanoSet

Returns the "default value" for a type.

impl Drop for NanoSet

fn drop(&mut self)

Executes the destructor for this type.

impl FromPy<PySet> for NanoSet

fn from_py(set: PySet, py: Python) -> Self

Performs the conversion.

impl IntoPy<PyObject> for NanoSet

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

Performs the conversion.

impl<'p> PyGCClearProtocol<'p> for NanoSet

impl<'p> PyGCProtocol<'p> for NanoSet

fn __traverse__(&'p self, visit: PyVisit) -> Result<(), PyTraverseError>

fn __clear__(&'p mut self)

impl<'p> PyGCTraverseProtocol<'p> for NanoSet

impl<'p> PyIterIterProtocol<'p> for NanoSet

type Success = PyObject

type Result = PyResult<PyObject>

impl<'p> PyIterProtocol<'p> for NanoSet

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

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

impl PyMethodsInventoryDispatch for NanoSet

type InventoryType = NanoSetGeneratedPyo3Inventory

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

impl<'p> PyNumberAndProtocol<'p> for NanoSet

type Left = &'p Self

type Right = &'p PyAny

type Success = PyObject

type Result = PyResult<PyObject>

impl<'p> PyNumberOrProtocol<'p> for NanoSet

type Left = &'p Self

type Right = &'p PyAny

type Success = PyObject

type Result = PyResult<PyObject>

impl<'p> PyNumberProtocol<'p> for NanoSet

fn __and__(
    lhs: <NanoSet as PyNumberAndProtocol<'p>>::Left,
    rhs: <NanoSet as PyNumberAndProtocol<'p>>::Right
) -> <NanoSet as PyNumberAndProtocol<'p>>::Result

fn __sub__(
    lhs: <NanoSet as PyNumberSubProtocol<'p>>::Left,
    rhs: <NanoSet as PyNumberSubProtocol<'p>>::Right
) -> <NanoSet as PyNumberSubProtocol<'p>>::Result

fn __or__(
    lhs: <NanoSet as PyNumberOrProtocol<'p>>::Left,
    rhs: <NanoSet as PyNumberOrProtocol<'p>>::Right
) -> <NanoSet as PyNumberOrProtocol<'p>>::Result

fn __xor__(
    lhs: <NanoSet as PyNumberXorProtocol<'p>>::Left,
    rhs: <NanoSet as PyNumberXorProtocol<'p>>::Right
) -> <NanoSet as PyNumberXorProtocol<'p>>::Result

fn __add__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberAddProtocol<'p>, 

fn __mul__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberMulProtocol<'p>, 

fn __matmul__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberMatmulProtocol<'p>, 

fn __truediv__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberTruedivProtocol<'p>, 

fn __floordiv__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberFloordivProtocol<'p>, 

fn __mod__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberModProtocol<'p>, 

fn __divmod__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberDivmodProtocol<'p>, 

fn __pow__(
    lhs: Self::Left,
    rhs: Self::Right,
    modulo: Self::Modulo
) -> Self::Result where
    Self: PyNumberPowProtocol<'p>, 

fn __lshift__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberLShiftProtocol<'p>, 

fn __rshift__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberRShiftProtocol<'p>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn __ipow__(
    &'p mut self,
    other: Self::Other,
    modulo: Self::Modulo
) -> Self::Result where
    Self: PyNumberIPowProtocol<'p>, 

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

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

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

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

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

fn __neg__(&'p self) -> Self::Result where
    Self: PyNumberNegProtocol<'p>, 

fn __pos__(&'p self) -> Self::Result where
    Self: PyNumberPosProtocol<'p>, 

fn __abs__(&'p self) -> Self::Result where
    Self: PyNumberAbsProtocol<'p>, 

fn __invert__(&'p self) -> Self::Result where
    Self: PyNumberInvertProtocol<'p>, 

fn __complex__(&'p self) -> Self::Result where
    Self: PyNumberComplexProtocol<'p>, 

fn __int__(&'p self) -> Self::Result where
    Self: PyNumberIntProtocol<'p>, 

fn __float__(&'p self) -> Self::Result where
    Self: PyNumberFloatProtocol<'p>, 

fn __round__(&'p self) -> Self::Result where
    Self: PyNumberRoundProtocol<'p>, 

fn __index__(&'p self) -> Self::Result where
    Self: PyNumberIndexProtocol<'p>, 

impl<'p> PyNumberSubProtocol<'p> for NanoSet

type Left = &'p Self

type Right = &'p PyAny

type Success = PyObject

type Result = PyResult<PyObject>

impl<'p> PyNumberXorProtocol<'p> for NanoSet

type Left = &'p Self

type Right = &'p PyAny

type Success = PyObject

type Result = PyResult<PyObject>

impl PyObjectAlloc for NanoSet

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

unsafe fn dealloc(py: Python, obj: *mut PyObject)

Calls the rust destructor for the object and frees the memory (usually by calling ptr->ob_type->tp_free). This function is used as tp_dealloc implementation.

unsafe fn drop(py: Python, obj: *mut PyObject)

Calls the rust destructor for the object.

impl<'p> PyObjectBoolProtocol<'p> for NanoSet

type Result = PyResult<bool>

impl<'p> PyObjectProtocol<'p> for NanoSet

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

fn __bool__(&'p self) -> <NanoSet as PyObjectBoolProtocol<'p>>::Result

fn __richcmp__(
    &'p self,
    obj: <NanoSet as PyObjectRichcmpProtocol<'p>>::Other,
    op: CompareOp
) -> <NanoSet as PyObjectRichcmpProtocol<'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 __hash__(&'p self) -> Self::Result where
    Self: PyObjectHashProtocol<'p>, 

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

impl<'p> PyObjectReprProtocol<'p> for NanoSet

type Success = PyObject

type Result = PyResult<PyObject>

impl<'p> PyObjectRichcmpProtocol<'p> for NanoSet

type Other = &'p PyAny

type Success = PyObject

type Result = PyResult<PyObject>

impl<'p> PySequenceContainsProtocol<'p> for NanoSet

type Item = &'p PyAny

type Result = PyResult<bool>

impl<'p> PySequenceLenProtocol<'p> for NanoSet

type Result = PyResult<usize>

impl<'p> PySequenceProtocol<'p> for NanoSet

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

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

type Type = NanoSet

Type of objects to store in PyObject struct

type BaseType = PyAny

Base class

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)

const SIZE: usize

Size of the rust PyObject structure (PyObject + rust structure)

const OFFSET: isize

Type instance offset inside PyObject structure

unsafe fn type_object() -> &'static mut PyTypeObject

PyTypeObject instance for this type, which might still need to be initialized

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