Struct MapReduceBuilder 

pub struct MapReduceBuilder<G: SwhForwardGraph + SwhBackwardGraph, MR: MapReducer, L: Labels> {
    pub map_reducer: MR,
    /* private fields */
}

Builder for MapReduce

Fields

map_reducer: MR

Implementations

impl<G: SwhForwardGraph + SwhBackwardGraph, MR: MapReducer<Label: Sized>> MapReduceBuilder<G, MR, SparseLabels<MR::Label>>

pub fn new_sparse(graph: G, map_reducer: MR) -> Self

Stores labels in a HashMap. This is the best when labeling the history-hosting layer

This improves memory usage at the expense of runtime and CPU use.

impl<G: SwhForwardGraph + SwhBackwardGraph, MR: MapReducer<Label: Default + Clone + Sized>> MapReduceBuilder<G, MR, DenseLabels<MR::Label>>

pub fn new_dense(graph: G, map_reducer: MR) -> Self

Stores labels in an array instead of a HashMap. This is the best when labeling the directory layer or the whole graph.

This improves runtime and CPU use at the expense of memory.

This should probably be used only if:

• labels are small, or
• computed labels are sparse (wrt. graph.num_nodes()) and None::<MR::Label> is small

impl<G: SwhForwardGraph + SwhBackwardGraph, MR: MapReducer<Label: StridableLabel>> MapReduceBuilder<G, MR, StriddenLabels<MR::Label>>

pub fn new_stridden(graph: G, map_reducer: MR, num_words: usize) -> Self

where MR::Label: StridableLabel + ToOwned,

Specialized variant of new_labels for non-Sized labels.

All labels must have the same length, but it can be computed at runtime.

Like Self::new_dense, this improves runtime and CPU use at the expense of memory, but less than boxing the values would.

This should only be used if labels are small.

num_words is the length of the [Label::Word] slice needed to store a label.

impl<G: SwhForwardGraph + SwhBackwardGraph, MR: MapReducer, L: Labels<Label = MR::Label>> MapReduceBuilder<G, MR, L>

pub fn num_nodes(self, num_nodes: usize) -> Self

pub fn cheap_clones(self, cheap_clones: bool) -> Self

Tunes the algorithm to assume labels are cheap to clone.

This is probably true if and only if the labels implement Copy. Setting this to true does not imply they are cheap to move.

Defaults to false.

pub fn keep_labels(self, keep_labels: bool) -> Self

Whether the algorithm should keep labels in its store in order to return them at the end

This is incompatible with cheap_clones(false) (the default).

This consumes extra memory, except when with_labels_array() and labels do not contain heap-allocated data.

Defaults to false.

pub fn build(self) -> Result<MapReduce<G, MR, L>>