Struct VocabularyInterpretation

pub struct VocabularyInterpretation<V: Vocabulary>(/* private fields */);

Vocabulary interpretation.

This type is a special sort of interpretation where every term is interpreted as itself.

Implementations

impl<V: Vocabulary> VocabularyInterpretation<V>

pub fn new() -> Self

Trait Implementations

impl<V: Vocabulary> BlankIdInterpretation<<V as BlankIdVocabulary>::BlankId> for VocabularyInterpretation<V>

where V::BlankId: Clone,

fn blank_id_interpretation( &self, blank_id: &V::BlankId, ) -> 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<V: Vocabulary> Default for VocabularyInterpretation<V>

fn default() -> Self

Returns the “default value” for a type.

impl<V: Vocabulary> Interpretation for VocabularyInterpretation<V>

type Resource = Term<Id<<V as IriVocabulary>::Iri, <V as BlankIdVocabulary>::BlankId>, <V as LiteralVocabulary>::Literal>

Resource identifier type.

impl<V: Vocabulary> IriInterpretation<<V as IriVocabulary>::Iri> for VocabularyInterpretation<V>

where V::Iri: Clone,

fn iri_interpretation(&self, iri: &V::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<V: Vocabulary> LiteralInterpretation<<V as LiteralVocabulary>::Literal> for VocabularyInterpretation<V>

where V::Literal: Clone,

fn literal_interpretation(&self, literal: &V::Literal) -> 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: LiteralRef<'_, V::Iri>, ) -> Option<Self::Resource>

impl<V: Vocabulary> ReverseBlankIdInterpretation for VocabularyInterpretation<V>

where V::Iri: Eq + Hash, V::BlankId: Eq + Hash, V::Literal: Eq + Hash,

type BlankId = <V as BlankIdVocabulary>::BlankId

type BlankIds<'a> = BlankIdsOf<'a, V> where V: 'a, V::Iri: 'a, V::BlankId: 'a, V::Literal: 'a

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

impl<V: Vocabulary> ReverseIriInterpretation for VocabularyInterpretation<V>

where V::Iri: Eq + Hash, V::BlankId: Eq + Hash, V::Literal: Eq + Hash,

type Iri = <V as IriVocabulary>::Iri

type Iris<'a> = IrisOf<'a, V> where V: 'a, V::Iri: 'a, V::BlankId: 'a, V::Literal: 'a

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

impl<V: Vocabulary> ReverseLiteralInterpretation for VocabularyInterpretation<V>

where V::Iri: Clone + Eq + Hash, V::BlankId: Clone + Eq + Hash, V::Literal: Clone + Eq + Hash,

type Literal = <V as LiteralVocabulary>::Literal

type Literals<'a> = LiteralsOf<'a, V> where V: 'a, V::Iri: 'a, V::BlankId: 'a, V::Literal: 'a

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