Struct Collector 

pub struct Collector<ITEM, COLLECTION, G = DynGeneratable<ITEM>>
where
    COLLECTION: Default + Extend<ITEM>,
    G: Generatable<ITEM>,
{ /* private fields */ }

A Computable that collects all items from a Generatable into a collection.

This is useful for converting a generator/stream of items into a single collected result. The collection type must implement Default and Extend.

Example

use computation_process::{Generator, GeneratorStep, Completable, Computable, Collector, Stateful, Generatable};

struct RangeStep;

impl GeneratorStep<u32, u32, u32> for RangeStep {
    fn step(max: &u32, current: &mut u32) -> Completable<Option<u32>> {
        *current += 1;
        if *current <= *max {
            Ok(Some(*current))
        } else {
            Ok(None)
        }
    }
}

let generator = Generator::<u32, u32, u32, RangeStep>::from_parts(3, 0);
let mut collector: Collector<u32, Vec<u32>> = generator.dyn_generatable().into();
let result = collector.compute().unwrap();
assert_eq!(result, vec![1, 2, 3]);

Implementations

impl<ITEM, COLLECTION, G> Collector<ITEM, COLLECTION, G>

where COLLECTION: Default + Extend<ITEM>, G: Generatable<ITEM>,

pub fn new(generator: G) -> Self

Create a new collector for the given generator.

Trait Implementations

impl<ITEM: Clone, COLLECTION, G> Clone for Collector<ITEM, COLLECTION, G>

where COLLECTION: Default + Extend<ITEM> + Clone, G: Generatable<ITEM> + Clone,

fn clone(&self) -> Collector<ITEM, COLLECTION, G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<ITEM, COLLECTION, G> Computable<COLLECTION> for Collector<ITEM, COLLECTION, G>

where COLLECTION: Default + Extend<ITEM>, G: Generatable<ITEM>,

fn try_compute(&mut self) -> Completable<COLLECTION>

Try to advance this computation, returning a value once the computation is done.

fn compute_completable(&mut self) -> Completable<T>

Advance this computation until it either completes, is canceled, or becomes exhausted, skipping over all suspended states.

fn compute(&mut self) -> Cancellable<T>

Advance this computation until completion, skipping over all suspended states.

fn dyn_computable(self) -> DynComputable<T>

where Self: Sized + 'static,

Utility method to convert this Computable to a dynamic type.

impl<ITEM: Debug, COLLECTION, G> Debug for Collector<ITEM, COLLECTION, G>

where COLLECTION: Default + Extend<ITEM> + Debug, G: Generatable<ITEM> + Debug,

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

Formats the value using the given formatter.

impl<'de, ITEM, COLLECTION, G> Deserialize<'de> for Collector<ITEM, COLLECTION, G>

where COLLECTION: Default + Extend<ITEM> + Serialize + for<'a> Deserialize<'a>, G: Generatable<ITEM> + Serialize + for<'a> Deserialize<'a>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<ITEM, COLLECTION: Default + Extend<ITEM>> From<Box<dyn Generatable<ITEM, Item = Result<ITEM, Cancelled>>>> for Collector<ITEM, COLLECTION, DynGeneratable<ITEM>>

fn from(value: DynGeneratable<ITEM>) -> Self

Converts to this type from the input type.

impl<ITEM: PartialEq, COLLECTION, G> PartialEq for Collector<ITEM, COLLECTION, G>

where COLLECTION: Default + Extend<ITEM> + PartialEq, G: Generatable<ITEM> + PartialEq,

fn eq(&self, other: &Collector<ITEM, COLLECTION, G>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<ITEM, COLLECTION, G> Serialize for Collector<ITEM, COLLECTION, G>

where COLLECTION: Default + Extend<ITEM> + Serialize + for<'a> Deserialize<'a>, G: Generatable<ITEM> + Serialize + for<'a> Deserialize<'a>,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<ITEM: Eq, COLLECTION, G> Eq for Collector<ITEM, COLLECTION, G>

where COLLECTION: Default + Extend<ITEM> + Eq, G: Generatable<ITEM> + Eq,

impl<ITEM, COLLECTION, G> StructuralPartialEq for Collector<ITEM, COLLECTION, G>

where COLLECTION: Default + Extend<ITEM>, G: Generatable<ITEM>,