Struct csvsc::MockStream

pub struct MockStream<I> { /* fields omitted */ }

A simple struct that helps create RowStreams from vectors.

Implementations

impl<I> MockStream<I> where
    I: Iterator<Item = RowResult>, 

pub fn new(iter: I, headers: Headers) -> MockStream<I>

Creates a new object implementing the RowStream trait from an iterator and some headers.

pub fn from_rows(iter: I) -> Result<MockStream<I>, BuildError>

Creates a new object implementing the RowStream trait from an iterator of RowResult objects, the first of which must be the header row.

Trait Implementations

impl<I: Debug> Debug for MockStream<I>

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

Formats the value using the given formatter.

impl<I> IntoIterator for MockStream<I> where
    I: Iterator<Item = RowResult>, 

type Item = RowResult

The type of the elements being iterated over.

type IntoIter = IntoIter<I>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<I> RowStream for MockStream<I> where
    MockStream<I>: IntoIterator<Item = RowResult>, 

pub 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.

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

Add a column to each row of the stream.

pub 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 .select().

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

Outputs only the selected columns, ignoring the rest.

pub 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.

pub 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.

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

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

pub 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.

pub 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.

pub fn rename(self, old_name: &str, new_name: &str) -> Rename<Self> where
    Self: Sized, 

Renames some columns

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

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

pub 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.

pub 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.

pub 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.