Struct kgdata::mapreduce::dataset::Dataset

pub struct Dataset<I> {
    pub items: Vec<I>,
}

Fields

items: Vec<I>

Implementations

impl Dataset<PathBuf>

pub fn files(glob: &str) -> Result<Self, KGDataError>

Trait Implementations

impl<I> FromIterator<I> for Dataset<I>

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = I>,

Creates a value from an iterator.

impl<I> FromParallelDataset<I> for Dataset<I>

where I: Send,

fn from_par_dataset<D>(iter: D) -> Self

where D: IntoParallelIterator<Item = I>,

impl<I> IntoParallelIterator for Dataset<I>

where I: Send,

type Iter = IntoIter<<Dataset<I> as IntoParallelIterator>::Item>

The parallel iterator type that will be created.

type Item = I

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl<I> ParallelDataset for Dataset<I>

where I: Send,

fn map<F, R>(self, op: F) -> MapOp<Self, F>

where F: Fn(Self::Item) -> R + Sync + Send, R: Send,

fn flat_map<F, R>(self, op: F) -> FlatMapOp<Self, F>

where F: Fn(Self::Item) -> R + Sync + Send, R: IntoParallelIterator,

fn filter<F>(self, op: F) -> FilterOp<Self, F>

where F: Fn(&Self::Item) -> bool + Sync,

fn fold<T, ID, F>(self, identity: ID, op: F) -> FoldOp<Self, ID, F>

where F: Fn(T, Self::Item) -> T + Sync + Send, ID: Fn() -> T + Sync + Send, T: Send,

fn reduce<ID, F>(self, identity: ID, op: F) -> Self::Item

where F: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send, ID: Fn() -> Self::Item + Sync + Send,

fn sort_by_key<F, K>(self, op: F, ascending: bool) -> SortByKeyOp<Self, F>

where F: Fn(&Self::Item) -> K + Sync, K: Ord + Send,

fn group_by<F, K>(self, key: F) -> MapDataset<K, Vec<Self::Item>>

where F: Fn(&Self::Item) -> K + Sync, K: Hash + Eq + Send,

fn group_by_map<K, V, F1, F2>(self, key: F1, value: F2) -> MapDataset<K, Vec<V>>

where F1: Fn(&Self::Item) -> K + Sync, F2: Fn(&Self::Item) -> V + Sync, K: Hash + Eq + Send, V: Send,

fn count(self) -> usize

fn take_any(self, n: usize) -> TakeAny<Self>

fn collect<C>(self) -> C

where C: FromParallelDataset<Self::Item>,