Struct WithGenerator 

pub struct WithGenerator<G, I = StaticDomain<Term>> { /* private fields */ }

Combines any RDF interpretation with a node id generator.

• Provides a GenDomain implementation, using the given generator to create fresh node identifiers.
• Assigns a node identifier to each new resource created by GenDomain::new_resource, based on the generator.

Note that in the case of the unit (()) interpretation, using GenDomain will give you a similar result but with other advantages (such as a ConstGenDomain implementation).

Implementations

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

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

Combines the given interpretation with the given generator.

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

Discards this wrapper, returning the inner interpretation and generator.

pub fn inner_interpretation(&self) -> &I

Returns a reference to the inner interpretation.

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

Returns a mutable reference to the inner interpretation.

pub fn generator(&self) -> &G

Returns a reference to the inner generator.

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

Returns a mutable reference to the inner generator.

pub fn into_inner_interpretation(self) -> I

Discards this wrapper and the generator, returning the inner interpretation.

pub fn into_generator(self) -> G

Discards this wrapper and the interpretation, returning the inner generator.

Trait Implementations

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

type Resource = <I as Domain>::Resource

Resource type.

impl<I: InterpretationMut, G: Generator> GenDomain for WithGenerator<G, I>

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

Create a new resource.

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

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

Interprets the given IRI, if possible.

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

Interprets the given literal, if possible.

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

Interprets the given ground term (an IRI or a literal), if possible.

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

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

Interprets the given IRI, inserting a fresh resource for it if none exists yet.

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

Interprets the given literal, inserting a fresh resource for it if none exists yet.

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

Interprets the given ground term, inserting a fresh resource for it if none exists yet.

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

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

Interprets the given blank node identifier, if possible.

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

Interprets the given term (a blank node identifier or a ground term), if possible.

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

Interprets the given identifier (a blank node identifier or an IRI), if possible.

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

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

Interprets the given blank node identifier, inserting a fresh resource for it if none exists yet.

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

Interprets the given term, inserting a fresh resource for it if none exists yet.

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

Interprets the given identifier, inserting a fresh resource for it if none exists yet.

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

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

Iterator over the IRIs of a resource.

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

Iterator over the literals of a resource.

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

Returns an iterator over the IRIs of resource.

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

Returns an iterator over the literals of resource.

fn ground_terms_of<'a>( &'a self, resource: &'a Self::Resource, ) -> GroundTermsOf<'a, Self>

Returns an iterator over the ground terms (IRIs and literals) of resource.

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

Checks whether resource has no ground term lexical representation.

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

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

Iterator over the blank node identifiers of a resource.

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

Returns an iterator over the blank node identifiers of resource.

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

Returns an iterator over the terms (ground terms and blank node identifiers) of resource.