Struct csvsc::AdjacentGroup

pub struct AdjacentGroup<I, F> { /* fields omitted */ }

Groups data by a set of columns.

The groups are passed to you as a RowStream object that you can use to manipulate them. Data grouped is such that the specified columns have exactly the same values. Once the value changes in the stream a new group is created. It is called adjacent because it does not group globally, i.e. multiple groups with the same grouping keys can be found if they are not adjacent.

If you add or delete headers you're responsible for modifying the headers also, which will be given to you as a parameter of the first closure.

Implementations

impl<I, F, R> AdjacentGroup<I, F> where
    I: RowStream,
    F: FnMut(MockStream<IntoIter<RowResult>>) -> R,
    R: RowStream, 

pub fn new<H>(
    iter: I,
    header_map: H,
    f: F,
    grouping: &[&str]
) -> Result<AdjacentGroup<I, F>, GroupBuildError> where
    H: FnMut(Headers) -> Headers, 

Trait Implementations

impl<I, F, R> IntoIterator for AdjacentGroup<I, F> where
    I: RowStream,
    F: FnMut(MockStream<IntoIter<RowResult>>) -> R,
    R: RowStream, 

type Item = RowResult

The type of the elements being iterated over.

type IntoIter = IntoIter<I::IntoIter, F, R>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<I, F, R> RowStream for AdjacentGroup<I, F> where
    I: RowStream,
    F: FnMut(MockStream<IntoIter<RowResult>>) -> R,
    R: RowStream, 

fn headers(&self) -> &Headers

Must return headers as they are in this point of the chain. For example if implementor adds a column, its headers() function must return the new headers including the one just added.

fn add(self, column: ColSpec) -> Result<Add<Self>, BuildError> where
    Self: Sized, 

Allows adding columns to each row of the stream.

fn del(self, columns: Vec<&str>) -> Del<Self> where
    Self: Sized, 

Deletes the specified columns from each row of the stream

fn add_with<F>(
    self,
    colname: &str,
    f: F
) -> Result<AddWith<Self, F>, BuildError> where
    Self: Sized,
    F: FnMut(&Headers, &Row) -> Result<String, BuildError>, 

Adds a column to each row of the stream using a closure to compute its value

fn reduce(
    self,
    columns: Vec<Box<dyn Aggregate>>
) -> Result<Reduce<Self>, BuildError> where
    Self: Sized, 

Group by one or more columns, compute aggregates and output the resulting columns

fn adjacent_group<H, F, R>(
    self,
    header_map: H,
    f: F,
    grouping: &[&str]
) -> Result<AdjacentGroup<Self, F>, GroupBuildError> where
    H: FnMut(Headers) -> Headers,
    F: FnMut(MockStream<IntoIter<RowResult>>) -> R,
    R: RowStream,
    Self: Sized, 

fn group<H, F, R>(
    self,
    header_map: H,
    f: F,
    grouping: &[&str]
) -> Result<Group<Self, F>, GroupBuildError> where
    H: FnMut(Headers) -> Headers,
    F: FnMut(MockStream<IntoIter<RowResult>>) -> R,
    R: RowStream,
    Self: Sized, 

fn flush(self, target: FlushTarget) -> Result<Flush<Self>, Error> where
    Self: Sized, 

When consumed, writes to destination specified by the column given in the first argument. Other than that this behaves like an id(x) function so you can specify more links in the chain and even more flushers.

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    Self: Sized,
    F: FnMut(&Headers, &RowResult), 

Mostly for debugging, calls a closure on each element. Behaves like the identity function on the stream returning each row untouched.

fn rename(self, name_map: &HashMap<&str, &str>) -> Rename<Self> where
    Self: Sized, 

Renames some columns

fn map_row<F>(self, f: F) -> MapRow<Self, F> where
    Self: Sized,
    F: Fn(&Headers, &Row) -> RowResult, 

Apply a function to an entire row

fn map_col<F>(self, col: String, f: F) -> MapCol<Self, F> where
    Self: Sized,
    F: Fn(&str) -> Result<String, BuildError>, 

Apply a function to a single column of the stream, this function dones't fail if the column dones't exist.