Struct IterListData 

pub struct IterListData<I: Iterator<Item = SEXP>> {
    len: usize,
    iter: RefCell<Option<I>>,
    cached: Cell<usize>,
    cache: OnceCell<PoolRoot>,
}

Iterator-backed list data with a rooted cache of the yielded R objects.

Construction does not advance the iterator or allocate R storage. The first in-bounds read allocates one list of the declared length, and each yielded object goes into it before the next call to Iterator::next. So the iterator can return fresh, unprotected objects, as in (0..n).map(|i| vec![i].into_sexp()). It remains responsible for rooting any R objects it keeps between calls.

The cache list is rooted in the same pool as owning ExternalPtr handles. The adapter roots it itself, so it is safe before it is attached to an ALTREP object, and releases it on drop. That pool releases in O(1) in any order: R’s finalizers drop ALTREP owners newest first, whatever order their caches were created in.

Reads generate only the requested prefix. Elements past the end of a short source read as R NULL; the source is dropped on its first None and never resumed. An infinite source is consumed only up to the declared length.

Clone copies the cache list, sharing its elements as R’s shallow_duplicate() does, and clones the remaining iterator without advancing it. Serialization realizes the declared prefix, NULLs included, and restoration needs no I. Delegate these data traits from a concrete #[derive(AltrepList)] class with #[altrep(manual, serialize, duplicate = "clone")].

The adapter is !Send + !Sync: build, read, clone and drop it on R’s main thread.

use miniextendr_api::{IntoR, altrep_data::IterListData};
let data = IterListData::from_exact_iter((0..5).map(|x| vec![x, x + 1].into_sexp()));

Fields

len: usize

iter: RefCell<Option<I>>

cached: Cell<usize>

cache: OnceCell<PoolRoot>

Implementations

impl<I: Iterator<Item = SEXP>> IterListData<I>

pub fn from_iter(iter: I, len: usize) -> Self

Create a lazy adapter for exactly the declared prefix.

fn cache(&self) -> SEXP

impl<I: ExactSizeIterator<Item = SEXP>> IterListData<I>

pub fn from_exact_iter(iter: I) -> Self

Create a lazy adapter using the iterator’s remaining length.

Trait Implementations

impl<I: Iterator<Item = SEXP>> AltListData for IterListData<I>

fn elt(&self, i: usize) -> SEXP

Get the list element at index i.

impl<I: Iterator<Item = SEXP>> AltrepLen for IterListData<I>

fn altrep_len(&self) -> usize

Returns the length of this ALTREP vector.

fn altrep_is_empty(&self) -> bool

Returns true if the vector is empty.

impl<I: Iterator<Item = SEXP>> AltrepSerialize for IterListData<I>

fn serialized_state(&self) -> SEXP

Convert the ALTREP data to a serializable R object.

fn unserialize(state: SEXP) -> Option<Self>

Reconstruct the ALTREP data from a serialized state.

impl<I: Iterator<Item = SEXP> + Clone> Clone for IterListData<I>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.