Struct rdf_types::interpretation::WithGenerator

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

Combines any RDF interpretation with a node id generator to make it implement InterpretationMut.

Use cases

() does not implement InterpretationMut

The transparent interpretation (the unit type ()) does not implement InterpretationMut because the new_resource method would require the creation of a fresh, unused, blank node identifier, which the transparent interpretation cannot create without a node id generator.

Resources returned by InterpretationMut::new_resource have no lexical representation

Interpreted resources are not required to have a lexical representation. This is most probably the case for new resources returned by InterpretationMut::new_resource. You can use WithGenerator to pair the interpretation with a node id generator so that new_resource will assign a lexical representation to new resources (a fresh blank node id for instance).

Implementations

impl<G, I> WithGenerator<G, I>

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

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

pub fn inner_interpretation(&self) -> &I

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

pub fn generator(&self) -> &G

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

pub fn into_inner_interpretation(self) -> I

pub fn into_generator(self) -> G

Trait Implementations

impl<B, I: BlankIdInterpretation<B>, G> BlankIdInterpretation<B> for WithGenerator<G, I>

fn blank_id_interpretation(&self, blank_id: &B) -> Option<Self::Resource>

Returns the interpretation of the given blank node identifier, if any.

fn lexical_blank_id_interpretation( &self, vocabulary: &impl BlankIdVocabulary<BlankId = B>, blank_id: &BlankId ) -> Option<Self::Resource>

where B: Sized,

impl<B, I: BlankIdInterpretationMut<B>, G> BlankIdInterpretationMut<B> for WithGenerator<G, I>

fn interpret_blank_id(&mut self, blank_id: B) -> Self::Resource

Interprets the given blank node identifier.

fn interpret_lexical_blank_id( &mut self, vocabulary: &mut impl BlankIdVocabularyMut<BlankId = B>, blank_id: &BlankId ) -> Self::Resource

fn interpret_owned_lexical_blank_id( &mut self, vocabulary: &mut impl BlankIdVocabularyMut<BlankId = B>, blank_id: BlankIdBuf ) -> Self::Resource

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

type Resource = <I as Interpretation>::Resource

Resource identifier type.

impl<V: IriVocabulary + BlankIdVocabulary, I, G: Generator<V>> InterpretationMut<V> for WithGenerator<G, I>

where I: IriInterpretationMut<V::Iri> + BlankIdInterpretationMut<V::BlankId>,

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

Creates a new resource.

impl<Iri, I: IriInterpretation<Iri>, G> IriInterpretation<Iri> for WithGenerator<G, I>

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

Returns the interpretation of the given IRI, if any.

fn lexical_iri_interpretation( &self, vocabulary: &impl IriVocabulary<Iri = I>, iri: &Iri ) -> Option<Self::Resource>

where I: Sized,

impl<Iri, I: IriInterpretationMut<Iri>, G> IriInterpretationMut<Iri> for WithGenerator<G, I>

fn interpret_iri(&mut self, iri: Iri) -> Self::Resource

Interprets the given IRI.

fn interpret_lexical_iri( &mut self, vocabulary: &mut impl IriVocabularyMut<Iri = I>, iri: &Iri ) -> Self::Resource

fn interpret_owned_lexical_iri( &mut self, vocabulary: &mut impl IriVocabularyMut<Iri = I>, iri: IriBuf ) -> Self::Resource

impl<L, I: LiteralInterpretation<L>, G> LiteralInterpretation<L> for WithGenerator<G, I>

fn literal_interpretation(&self, literal: &L) -> Option<Self::Resource>

Returns the interpretation of the given literal value, if any.

fn lexical_literal_interpretation<V: LiteralVocabulary<Literal = L>>( &self, vocabulary: &V, literal: &Literal<V::Iri> ) -> Option<Self::Resource>

impl<L, I: LiteralInterpretationMut<L>, G> LiteralInterpretationMut<L> for WithGenerator<G, I>

fn interpret_literal(&mut self, literal: L) -> Self::Resource

Interprets the given literal value.

fn interpret_lexical_literal<V: LiteralVocabularyMut<Literal = L>>( &mut self, vocabulary: &mut V, literal: &Literal<V::Iri> ) -> Self::Resource

fn interpret_owned_lexical_literal<V: LiteralVocabularyMut<Literal = L>>( &mut self, vocabulary: &mut V, literal: Literal<V::Iri> ) -> Self::Resource

fn interpret_full_lexical_literal( &mut self, vocabulary: &mut (impl IriVocabularyMut + LiteralVocabularyMut<Literal = L>), literal: Literal ) -> Self::Resource

impl<I: ReverseBlankIdInterpretation, G> ReverseBlankIdInterpretation for WithGenerator<G, I>

type BlankId = <I as ReverseBlankIdInterpretation>::BlankId

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

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

impl<I: ReverseBlankIdInterpretationMut, G> ReverseBlankIdInterpretationMut for WithGenerator<G, I>

fn assign_blank_id( &mut self, id: &Self::Resource, blank_id: Self::BlankId ) -> bool

impl<I: ReverseIriInterpretation, G> ReverseIriInterpretation for WithGenerator<G, I>

type Iri = <I as ReverseIriInterpretation>::Iri

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

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

impl<I: ReverseIriInterpretationMut, G> ReverseIriInterpretationMut for WithGenerator<G, I>

fn assign_iri(&mut self, id: &Self::Resource, iri: Self::Iri) -> bool

impl<I: ReverseLiteralInterpretation, G> ReverseLiteralInterpretation for WithGenerator<G, I>

type Literal = <I as ReverseLiteralInterpretation>::Literal

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

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

impl<I: ReverseLiteralInterpretationMut, G> ReverseLiteralInterpretationMut for WithGenerator<G, I>

fn assign_literal( &mut self, resource: &Self::Resource, literal: Self::Literal ) -> bool

Assigns the given literal to the given resource.