Trait LinkedDataDeserializer 

pub trait LinkedDataDeserializer<R = Term> {
    type Error: Error<R>;

    // Required methods
    fn interpret(&mut self, term: CowTerm<'_>) -> Result<R, Self::Error>;
    fn terms_of<'a>(
        &'a self,
        resource: &'a R,
    ) -> Result<impl Iterator<Item = Result<CowTerm<'a>, Self::Error>>, Self::Error>;
    fn peek_resources<'a>(
        &'a self,
    ) -> Result<impl Iterator<Item = Result<&'a R, Self::Error>>, Self::Error>
       where R: 'a;
    fn deserialize_resource(
        &mut self,
        resource: Option<R>,
    ) -> Result<Option<R>, Self::Error>;
    fn peek_quads<'p>(
        &'p self,
        pattern: impl Into<LinearQuadPattern<&'p R>>,
    ) -> Result<impl Iterator<Item = Result<Quad<&'p R>, Self::Error>>, Self::Error>
       where R: 'p;
    fn deserialize_quad<'p>(
        &mut self,
        pattern: impl Into<LinearQuadPattern<&'p R>>,
    ) -> Result<Option<Quad<R>>, Self::Error>
       where R: 'p;

    // Provided methods
    fn as_dyn_mut<'a>(
        &'a mut self,
    ) -> &'a mut (dyn DynLinkedDataDeserializer<R, Error = Self::Error> + 'a)
       where Self: Sized { ... }
    fn is_iri(&self, resource: &R, iri: &Iri) -> Result<bool, Self::Error> { ... }
    fn peek_resource<'a>(&'a self) -> Result<Option<&'a R>, Self::Error>
       where R: 'a { ... }
    fn peek_quad<'p>(
        &'p self,
        pattern: impl Into<LinearQuadPattern<&'p R>>,
    ) -> Result<Option<Quad<&'p R>>, Self::Error>
       where R: 'p { ... }
}

Required Associated Types

type Error: Error<R>

Required Methods

fn interpret(&mut self, term: CowTerm<'_>) -> Result<R, Self::Error>

fn terms_of<'a>( &'a self, resource: &'a R, ) -> Result<impl Iterator<Item = Result<CowTerm<'a>, Self::Error>>, Self::Error>

fn peek_resources<'a>( &'a self, ) -> Result<impl Iterator<Item = Result<&'a R, Self::Error>>, Self::Error>

where R: 'a,

fn deserialize_resource( &mut self, resource: Option<R>, ) -> Result<Option<R>, Self::Error>

fn peek_quads<'p>( &'p self, pattern: impl Into<LinearQuadPattern<&'p R>>, ) -> Result<impl Iterator<Item = Result<Quad<&'p R>, Self::Error>>, Self::Error>

where R: 'p,

fn deserialize_quad<'p>( &mut self, pattern: impl Into<LinearQuadPattern<&'p R>>, ) -> Result<Option<Quad<R>>, Self::Error>

where R: 'p,

Provided Methods

fn as_dyn_mut<'a>( &'a mut self, ) -> &'a mut (dyn DynLinkedDataDeserializer<R, Error = Self::Error> + 'a)

where Self: Sized,

fn is_iri(&self, resource: &R, iri: &Iri) -> Result<bool, Self::Error>

fn peek_resource<'a>(&'a self) -> Result<Option<&'a R>, Self::Error>

where R: 'a,

fn peek_quad<'p>( &'p self, pattern: impl Into<LinearQuadPattern<&'p R>>, ) -> Result<Option<Quad<&'p R>>, Self::Error>

where R: 'p,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<R, S: ?Sized + LinkedDataDeserializer<R>> LinkedDataDeserializer<R> for &mut S

type Error = <S as LinkedDataDeserializer<R>>::Error

fn interpret(&mut self, term: CowTerm<'_>) -> Result<R, Self::Error>

fn terms_of<'a>( &'a self, resource: &'a R, ) -> Result<impl Iterator<Item = Result<CowTerm<'a>, Self::Error>>, Self::Error>

fn peek_resources<'a>( &'a self, ) -> Result<impl Iterator<Item = Result<&'a R, Self::Error>>, Self::Error>

where R: 'a,

fn deserialize_resource( &mut self, resource: Option<R>, ) -> Result<Option<R>, Self::Error>

fn peek_quads<'p>( &'p self, pattern: impl Into<LinearQuadPattern<&'p R>>, ) -> Result<impl Iterator<Item = Result<Quad<&'p R>, Self::Error>>, Self::Error>

where R: 'p,

fn deserialize_quad<'p>( &mut self, pattern: impl Into<LinearQuadPattern<&'p R>>, ) -> Result<Option<Quad<R>>, Self::Error>

where R: 'p,

Implementors

impl<'a, R: Clone + Ord, D: LinkedDataDeserializer<R>> LinkedDataDeserializer<R> for FlattenDeserializer<'a, D, R>

type Error = <D as LinkedDataDeserializer<R>>::Error

impl<'d, R, E> LinkedDataDeserializer<R> for dyn DynLinkedDataDeserializer<R, Error = E> + 'd

where E: Error<R>,

type Error = E

impl<D, I> LinkedDataDeserializer<<I as Domain>::Resource> for DatasetDeserializer<D, I>

where D: PatternMatchingDatasetMut<Resource = I::Resource>, I: TryReverseInterpretation + TryInterpretationMut, I::Resource: Clone,

type Error = DatasetDeserializerError

impl<R: Clone + Ord, D: LinkedDataDeserializer<R>> LinkedDataDeserializer<R> for ReplayDeserializer<D, R>

type Error = <D as LinkedDataDeserializer<R>>::Error

impl<R: Ord, D: LinkedDataDeserializer<R>> LinkedDataDeserializer<R> for ResourcesDeserializer<R, D>

type Error = <D as LinkedDataDeserializer<R>>::Error