Struct rdf_types::interpretation::Indexed

pub struct Indexed { /* private fields */ }

Implementations

impl Indexed

pub fn new() -> Self

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl BlankIdInterpretation<BlankIdIndex> for Indexed

fn blank_id_interpretation( &self, blank_id: &BlankIdIndex ) -> 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>

impl BlankIdInterpretationMut<BlankIdIndex> for Indexed

fn interpret_blank_id(&mut self, blank_id: BlankIdIndex) -> 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 Clone for Indexed

fn clone(&self) -> Indexed

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Indexed

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Indexed

fn default() -> Indexed

Returns the “default value” for a type.

impl Interpretation for Indexed

type Resource = ResourceIndex

Resource identifier type.

type Resources<'a> = ResourceIndexIter

Interpreted resource iterator.

fn resources(&self) -> Self::Resources<'_>

Returns an iterator over the interpreted resources.

impl IriInterpretation<IriIndex> for Indexed

fn iri_interpretation(&self, iri: &IriIndex) -> 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>

impl IriInterpretationMut<IriIndex> for Indexed

fn interpret_iri(&mut self, iri: IriIndex) -> 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 LiteralInterpretation<LiteralIndex> for Indexed

fn literal_interpretation( &self, literal: &LiteralIndex ) -> 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::Type, V::Value> ) -> Option<Self::Resource>

impl LiteralInterpretationMut<LiteralIndex> for Indexed

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

Interprets the given literal value.

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

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

fn interpret_full_lexical_literal<V>( &mut self, vocabulary: &mut V, literal: Literal<Type<IriBuf, LanguageTagBuf>, V::Value> ) -> Self::Resourcewhere V: LiteralVocabularyMut<Literal = L, Type = Type<V::Iri, V::LanguageTag>> + IriVocabularyMut + LanguageTagVocabularyMut,

impl PartialEq<Indexed> for Indexed

fn eq(&self, other: &Indexed) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ReverseIdInterpretation for Indexed

type Iri = IriIndex

type BlankId = BlankIdIndex

type Iris<'a> = Flatten<IntoIter<Iter<'a, IriIndex>>>

type BlankIds<'a> = Flatten<IntoIter<Iter<'a, BlankIdIndex>>>

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

Returns an iterator over the IRIs of the given resource.

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

Returns an iterator over the blank node identifiers of the given resource.

fn ids_of(&self, id: &Self::Resource) -> IdsOf<'_, Self>

impl ReverseTermInterpretation for Indexed

type IdRef<'a> where Self: 'a = Id<&'a IriIndex, &'a BlankIdIndex>

type LiteralRef<'a> where Self: 'a = &'a LiteralIndex

type Ids<'a> = IdsOf<'a, Indexed>

type Literals<'a> = Flatten<IntoIter<Iter<'a, LiteralIndex>>>

fn ids_of(&self, id: &Self::Resource) -> Self::Ids<'_>

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

fn terms_of(&self, id: &Self::Resource) -> TermsOf<'_, Self>

fn term_of( &self, id: &Self::Resource ) -> Option<Term<Self::IdRef<'_>, Self::LiteralRef<'_>>>

fn has_term(&self, id: &Self::Resource) -> bool

impl ReverseTermInterpretationMut for Indexed

type Id = Id<IriIndex, BlankIdIndex>

type Literal = LiteralIndex

fn assign_id(&mut self, resource: Self::Resource, id: Self::Id) -> bool

Assigns the given id to the given resource.

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

Assigns the given literal to the given resource.

fn assign_term( &mut self, resource: Self::Resource, term: Term<Self::Id, Self::Literal> ) -> bool

Assigns the given term to the given resource.

fn assign_terms( &mut self, f: impl FnMut(&Self, &Self::Resource) -> Option<Term<Self::Id, Self::Literal>> )

Assigns a term to all the interpreted resources.

fn generate_ids<N: Namespace<Id = Self::Id>>( &mut self, namespace: &mut N, generator: &mut impl Generator<N> )where Self: ReverseTermInterpretationMut,

Generates and assign a node identifier for all the resources that don’t have any term, using the given generator.

impl Eq for Indexed

impl StructuralEq for Indexed

impl StructuralPartialEq for Indexed