Struct csvsc::input::InputStream

pub struct InputStream { /* fields omitted */ }

A structure for creating a transformation chain from input files.

Most of the time you’ll start your processing chain using .from_readers() or .from_paths() and then chain the methods of the RowStream trait. However there are more options for the cases where you need to customize how your input is read.

Trait Implementations

impl IntoIterator for InputStream

type Item = RowResult

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl RowStream for InputStream

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>> where
    Self: Sized, 

Add a column 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. If you have too many columns to delete perhaps instead use RowStream::select.

fn select(self, columns: Vec<&str>) -> Select<'_, Self> where
    Self: Sized, 

Outputs only the selected columns, ignoring the rest.

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

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>> where
    Self: Sized, 

Reduce all the incoming stream into one row, computing some aggregates in the way. All the stream collapses into one row.

fn adjacent_group<F, R, G>(self, grouping: G, f: F) -> AdjacentGroup<Self, F, G> where
    F: Fn(MockStream<IntoIter<RowResult>>) -> R,
    R: RowStream,
    G: GroupCriteria,
    Self: Sized, 

Groups rows by the given criteria, but assuming a “group” is a set of adjacent rows.

fn group<F, R, G>(self, grouping: G, f: F) -> Group<Self, F, G> where
    F: Fn(MockStream<IntoIter<RowResult>>) -> R,
    R: RowStream,
    G: GroupCriteria,
    Self: Sized, 

Groups rows by the given criteria. You’ll be given a RowStream instance as the first argument of a closure that you can use to further process the grouped rows.

fn flush<T>(self, target: T) -> Result<Flush<Self, T>> 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 review<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, old_name: &str, new_name: &str) -> Rename<Self> where
    Self: Sized, 

Renames some columns

fn map_row<F, H, R>(self, f: F, header_map: H) -> MapRow<Self, F> where
    Self: Sized,
    F: Fn(&Headers, &Row) -> Result<R>,
    H: Fn(&Headers) -> Headers,
    R: Iterator<Item = RowResult>, 

Apply a function to every row and use the return values to build the row stream.

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

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

fn filter_col<F>(self, col: &str, f: F) -> Result<FilterCol<Self, F>> where
    Self: Sized,
    F: Fn(&str) -> bool, 

filter entire rows out depending on one column’s value and a condition, leaving errored rows untouched.

fn filter_row<F>(self, f: F) -> FilterRow<Self, F> where
    Self: Sized,
    F: Fn(&Headers, &Row) -> bool, 

filter entire rows out depending on one column’s value and a condition, leaving errored rows untouched.