Struct WithLocalGenerator 

pub struct WithLocalGenerator<G, I = ()> { /* private fields */ }

Implementations

impl<G, I> WithLocalGenerator<G, I>

pub const fn new(interpretation: I, generator: G) -> Self

pub fn into_parts(self) -> (I, G)

pub const fn inner_interpretation(&self) -> &I

pub const fn inner_interpretation_mut(&mut self) -> &mut I

pub const fn generator(&self) -> &G

pub const fn generator_mut(&mut self) -> &mut G

pub fn into_inner_interpretation(self) -> I

pub fn into_generator(self) -> G

Trait Implementations

impl<I: LocalInterpretationMut, G: LocalGenerator> GenerativeInterpretation for WithLocalGenerator<G, I>

fn new_resource(&mut self) -> Self::Resource

Create a new resource.

impl<I: Interpretation, G> Interpretation for WithLocalGenerator<G, I>

type Resource = <I as Interpretation>::Resource

fn iri(&self, iri: Iri<&str>) -> Option<Self::Resource>

fn literal<'a>( &self, literal: impl Into<LiteralRef<'a>>, ) -> Option<Self::Resource>

fn term<'a>(&self, term: impl Into<TermRef<'a>>) -> Option<Self::Resource>

impl<I: InterpretationMut, G> InterpretationMut for WithLocalGenerator<G, I>

fn insert_iri<'a>(&mut self, iri: impl Into<Cow<'a, IriBuf>>) -> Self::Resource

fn insert_literal<'a>( &mut self, literal: impl Into<CowLiteral<'a>>, ) -> Self::Resource

fn insert_term<'a>(&mut self, term: impl Into<CowTerm<'a>>) -> Self::Resource

impl<I: LocalInterpretation, G> LocalInterpretation for WithLocalGenerator<G, I>

fn blank_id<'a>(&'a self, blank_id: &'a BlankId) -> Option<Self::Resource>

fn local_term<'a>( &self, term: impl Into<LocalTermRef<'a>>, ) -> Option<Self::Resource>

fn triple_term(&self, _t: TripleTerm) -> Option<Self::Resource>

Looks up a triple-term resource (RDF 1.2). Default implementation returns None — interpretations that store triple terms should override.

fn id<'a>(&self, id: impl Into<IdRef<'a>>) -> Option<Self::Resource>

impl<I: LocalInterpretationMut, G> LocalInterpretationMut for WithLocalGenerator<G, I>

fn insert_blank_id<'a>( &mut self, blank_id: impl Into<Cow<'a, BlankId>>, ) -> Self::Resource

fn insert_local_term<'a>( &mut self, term: impl Into<CowLocalTerm<'a>>, ) -> Self::Resource

fn insert_triple_term(&mut self, _t: TripleTerm) -> Self::Resource

Inserts a triple-term resource (RDF 1.2). Default implementation panics — interpretations that need to ingest triple-term-bearing graphs must override this method.

fn insert_id<'a>(&mut self, term: impl Into<CowId<'a>>) -> Self::Resource

impl<I: ReverseInterpretation, G> ReverseInterpretation for WithLocalGenerator<G, I>

type Iris<'a> = <I as ReverseInterpretation>::Iris<'a> where Self: 'a

type Literals<'a> = <I as ReverseInterpretation>::Literals<'a> where Self: 'a

fn iris_of<'a>(&'a self, resource: &'a Self::Resource) -> Self::Iris<'a>

fn literals_of<'a>(&'a self, resource: &'a Self::Resource) -> Self::Literals<'a>

fn triple_term_components( &self, resource: &Self::Resource, ) -> Option<(Self::Resource, Self::Resource, Self::Resource)>

RDF 1.2: returns the components of a triple-term resource as (subject, predicate, object) if resource denotes a triple term. Default returns None (no triple-term recognition); interpretations that store triple terms should override.

fn triple_term_components_view<'a>( &'a self, resource: &'a Self::Resource, ) -> Option<(Cow<'a, Self::Resource>, Cow<'a, Self::Resource>, Cow<'a, Self::Resource>)>

where Self::Resource: Clone,

Borrow-or-own view of triple-term components — the zero-clone counterpart of Self::triple_term_components.

fn terms_of<'a>(&'a self, resource: &'a Self::Resource) -> TermsOf<'a, Self>

fn is_blank_id(&self, resource: &Self::Resource) -> bool

impl<I: ReverseLocalInterpretation, G> ReverseLocalInterpretation for WithLocalGenerator<G, I>

type BlankIds<'a> = <I as ReverseLocalInterpretation>::BlankIds<'a> where Self: 'a

fn blank_ids_of<'a>( &'a self, resource: &'a Self::Resource, ) -> Self::BlankIds<'a>

fn local_terms_of<'a>( &'a self, resource: &'a Self::Resource, ) -> LocalTermsOf<'a, Self>