Enum sophia::parser::rio_common::GeneralizedRioSource

pub enum GeneralizedRioSource<T, E> {
    Parser(T),
    Error(Option<E>),
}

QuadSource adapter for RIO GeneralizedQuadParser

Variants

Parser(T)

Error(Option<E>)

Trait Implementations

impl<T, E> From<Result<T, E>> for GeneralizedRioSource<T, E>

fn from(res: StdResult<T, E>) -> Self

Performs the conversion.

impl<T, E> QuadSource for GeneralizedRioSource<T, E> where
    T: GeneralizedQuadsParser<Error = E>,
    E: Error + 'static, 

type Error = E

The type of errors produced by this source.

type Quad = ByRefTerms

Determine the type of Quads that this quad source yields. (see streaming_mode

fn try_for_some_quad<F, EF>(&mut self, f: &mut F) -> StreamResult<bool, E, EF> where
    F: FnMut(StreamedQuad<Self::Quad>) -> Result<(), EF>,
    EF: Error, 

Call f for at least one quad from this quad source, if any.

fn try_for_each_quad<F, E>(&mut self, f: F) -> StreamResult<(), Self::Error, E> where
    F: FnMut(StreamedQuad<Self::Quad>) -> Result<(), E>,
    E: Error, 

Call f for all quads from this quad source.

fn for_some_quad<F>(&mut self, f: &mut F) -> Result<bool, Self::Error> where
    F: FnMut(StreamedQuad<Self::Quad>), 

Call f for at least one quad from this quad source, if any.

fn for_each_quad<F>(&mut self, f: F) -> Result<(), Self::Error> where
    F: FnMut(StreamedQuad<Self::Quad>), 

Call f for all quads from this quad source.

fn in_dataset<D: MutableDataset>(
    &mut self,
    dataset: &mut D
) -> StreamResult<usize, Self::Error, <D as MutableDataset>::MutationError> where
    Self: Sized, 

Insert all quads from this source into the given dataset.

fn filter_quads<F>(self, filter: F) -> FilterSource<Self, F> where
    Self: Sized,
    F: FnMut(&StreamedQuad<Self::Quad>) -> bool, 

Creates a quad source which uses a closure to determine if a quad should be yielded.

fn filter_map_quads<F, T>(self, filter_map: F) -> FilterMapSource<Self, F> where
    Self: Sized,
    F: FnMut(StreamedQuad<Self::Quad>) -> Option<T>, 

Creates a quad source that both filters and maps.

fn map_quads<F, T>(self, map: F) -> MapSource<Self, F> where
    Self: Sized,
    F: FnMut(StreamedQuad<Self::Quad>) -> T, 

Takes a closure and creates quad source which yield the result of that closure for each quad.