Enum Collector 

pub enum Collector {
    Count {
        distinct: Option<bool>,
        map: Option<WasmFunction>,
    },
    Sum {
        map: WasmFunction,
    },
    Average {
        map: WasmFunction,
    },
    Min {
        map: WasmFunction,
        comparator: WasmFunction,
    },
    Max {
        map: WasmFunction,
        comparator: WasmFunction,
    },
    ToList {
        map: Option<WasmFunction>,
    },
    ToSet {
        map: Option<WasmFunction>,
    },
    Compose {
        collectors: Vec<Collector>,
        combiner: WasmFunction,
    },
    Conditionally {
        predicate: WasmFunction,
        collector: Box<Collector>,
    },
    CollectAndThen {
        collector: Box<Collector>,
        mapper: WasmFunction,
    },
    LoadBalance {
        map: WasmFunction,
        load: Option<WasmFunction>,
    },
}

Variants

Count

Fields

distinct: Option<bool>

map: Option<WasmFunction>

Sum

Fields

map: WasmFunction

Average

Fields

map: WasmFunction

Min

Fields

map: WasmFunction

comparator: WasmFunction

Max

Fields

map: WasmFunction

comparator: WasmFunction

ToList

Fields

map: Option<WasmFunction>

ToSet

Fields

map: Option<WasmFunction>

Compose

Fields

collectors: Vec<Collector>

combiner: WasmFunction

Conditionally

Fields

predicate: WasmFunction

collector: Box<Collector>

CollectAndThen

Fields

collector: Box<Collector>

mapper: WasmFunction

LoadBalance

Fields

map: WasmFunction

load: Option<WasmFunction>

Implementations

impl Collector

pub fn count() -> Self

pub fn count_distinct() -> Self

pub fn count_with_map(map: WasmFunction) -> Self

pub fn sum(map: WasmFunction) -> Self

pub fn average(map: WasmFunction) -> Self

pub fn min(map: WasmFunction, comparator: WasmFunction) -> Self

pub fn max(map: WasmFunction, comparator: WasmFunction) -> Self

pub fn to_list() -> Self

pub fn to_list_with_map(map: WasmFunction) -> Self

pub fn to_set() -> Self

pub fn to_set_with_map(map: WasmFunction) -> Self

pub fn compose(collectors: Vec<Collector>, combiner: WasmFunction) -> Self

pub fn conditionally(predicate: WasmFunction, collector: Collector) -> Self

pub fn collect_and_then(collector: Collector, mapper: WasmFunction) -> Self

pub fn load_balance(map: WasmFunction) -> Self

pub fn load_balance_with_load(map: WasmFunction, load: WasmFunction) -> Self

Trait Implementations

impl Clone for Collector

fn clone(&self) -> Collector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Collector

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Collector

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Collector

fn eq(&self, other: &Collector) -> 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 Serialize for Collector

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Collector

impl StructuralPartialEq for Collector