Struct 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>

where B: Sized,

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 duplicate 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.

impl<V> InterpretationMut<V> for Indexed

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

Creates a new resource.

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>

where I: Sized,

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: LiteralRef<'_, V::Iri>, ) -> 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: LiteralRef<'_, 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 PartialEq for Indexed

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl ReverseBlankIdInterpretation for Indexed

type BlankId = BlankIdIndex

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

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

impl ReverseBlankIdInterpretationMut for Indexed

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

impl ReverseIriInterpretation for Indexed

type Iri = IriIndex

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

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

impl ReverseIriInterpretationMut for Indexed

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

impl ReverseLiteralInterpretation for Indexed

type Literal = LiteralIndex

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

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

impl ReverseLiteralInterpretationMut for Indexed

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

Assigns the given literal to the given resource.

impl TraversableInterpretation for Indexed

type Resources<'a> = ResourceIndexIter<'a>

Interpreted resource iterator.

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

Returns an iterator over the interpreted resources.

impl Eq for Indexed

impl StructuralPartialEq for Indexed