Struct PositionIterInternal 

pub struct PositionIterInternal<T> {
    pub status: IterStatus<T>,
    pub position: usize,
}

Fields

status: IterStatus<T>

position: usize

Implementations

impl<T> PositionIterInternal<T>

pub const fn new(obj: T, position: usize) -> Self

pub fn set_state<F>( &mut self, state: &PyObject, f: F, vm: &VirtualMachine, ) -> PyResult<()>

where F: FnOnce(&T, usize) -> usize,

pub fn reduce<F, E>( &self, func: PyObjectRef, active: F, empty: E, vm: &VirtualMachine, ) -> PyTupleRef

where F: FnOnce(&T) -> PyObjectRef, E: FnOnce(&VirtualMachine) -> PyObjectRef,

Build a pickle-compatible reduce tuple.

func must be resolved before acquiring any lock that guards this PositionIterInternal, so that the builtins lookup cannot trigger reentrant iterator access and deadlock.

pub fn exhaust(&mut self) -> Option<T>

Mark this exhausted and hand back what it was holding, for the caller to release once it has dropped the lock guarding this. Releasing it under that lock would let a __del__ that iterates again deadlock.

pub fn next<F>(&mut self, f: F) -> (PyResult<PyIterReturn>, Option<T>)

where F: FnOnce(&T, usize) -> PyResult<PyIterReturn>,

Advance, along with what this was holding if the step exhausted it. See Self::exhaust for why the caller is handed it rather than the drop happening here; locked_next does the release for the common case.

pub fn rev_next<F>(&mut self, f: F) -> (PyResult<PyIterReturn>, Option<T>)

where F: FnOnce(&T, usize) -> PyResult<PyIterReturn>,

Self::next walking backwards, exhausted once it steps off the front.

pub fn length_hint<F>(&self, f: F) -> usize

where F: FnOnce(&T) -> usize,

pub fn rev_length_hint<F>(&self, f: F) -> usize

where F: FnOnce(&T) -> usize,

Trait Implementations

impl<T: Debug> Debug for PositionIterInternal<T>

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

Formats the value using the given formatter.

impl<T: Traverse> Traverse for PositionIterInternal<T>

fn traverse(&self, tracer_fn: &mut TraverseFn<'_>)

impl traverse() with caution! Following those guideline so traverse doesn’t cause memory error!:

fn clear(&mut self, _out: &mut Vec<PyObjectRef>)

Extract all owned child PyObjectRefs for circular reference resolution (tp_clear). Called just before object deallocation to break circular references. Default implementation does nothing.