Struct GroupedDataFrame 

pub struct GroupedDataFrame {
    source: DataFrame,
    groups: Vec<(GroupKey, Vec<usize>)>,
}

A DataFrame partitioned by the values of one key column.

Produced by DataFrame::group_by. Holds the source frame plus one (key, row-indices) pair per group; nothing is copied until you ask for frames or extract.

GC rooting

The source frame is preserved on R’s precious list (R_PreserveObject) for this struct’s lifetime and released on drop — order-independent, unlike the PROTECT stack, so the struct can be held across arbitrary allocations (e.g. a locally built frame from DataFrame::builder, which is unprotected once build() returns). Without this, the per-group allocations in frames / extract could collect the source mid-iteration. Main-thread-only (holds a SEXP; !Send).

Fields

source: DataFrame

groups: Vec<(GroupKey, Vec<usize>)>

Implementations

impl GroupedDataFrame

fn new(source: DataFrame, groups: Vec<(GroupKey, Vec<usize>)>) -> Self

Root source on R’s precious list and pair it with precomputed groups.

R_PreserveObject conses onto the precious list — an allocation that can itself GC — so PROTECT source across the call. Released on Drop.

pub fn len(&self) -> usize

Number of groups (empty factor levels included).

pub fn is_empty(&self) -> bool

Whether there are no groups.

pub fn source(&self) -> &DataFrame

The frame this grouping was computed from.

pub fn iter(&self) -> impl Iterator<Item = (&GroupKey, &[usize])>

Iterate (key, row-indices) pairs in group order. Indices are 0-based rows of source.

pub fn frames(&self) -> impl Iterator<Item = (&GroupKey, BuiltDataFrame)>

Iterate (key, sub-frame) pairs, materialising each group as its own frame via DataFrame::select_rows.

Main thread only. Each yielded frame is an owned, GC-rooted BuiltDataFrame (#1247) — safe to hold across later iterations’ allocations. Deref (*sub) to pass the view where a DataFrame is expected, e.g. to NamedDataFrameListBuilder::push (which protects on push, so the handle may drop right after).

pub fn extract<T>(&self) -> Result<Vec<(GroupKey, Vec<T>)>, DataFrameError>

where Vec<T>: FromDataFrame,

Extract typed rows once, then partition them by group.

One Vec::<T>::from_dataframe pass over the whole frame, then a move-partition by the stored indices — no per-group R subsetting and no Clone bound. The result is plain Rust data (rayon-safe afterwards).

Trait Implementations

impl Drop for GroupedDataFrame

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes