Enum Id

pub enum Id<I = IriBuf, B = BlankIdBuf> {
    Valid(Id<I, B>),
    Invalid(String),
}

Node identifier.

Used to reference a node across a document or to a remote document. It can be an identifier (IRI), a blank node identifier for local blank nodes or an invalid reference (a string that is neither an IRI nor blank node identifier).

Hash implementation

It is guaranteed that the Hash implementation of Id is transparent, meaning that the hash of Id::Valid(id) the same as id, and the hash of Id::Invalid(id) is the same as id.

This may be useful to define custom indexmap::Equivalent<Id<I, B>> implementation.

Variants

Valid(Id<I, B>)

Valid node identifier.

Invalid(String)

Invalid reference.

Implementations

impl<I, B> Id<I, B>

where I: From<IriBuf>, B: From<BlankIdBuf>,

pub fn from_string(s: String) -> Id<I, B>

impl<I, B> Id<I, B>

pub fn iri(iri: I) -> Id<I, B>

pub fn blank(b: B) -> Id<I, B>

pub fn from_string_in( vocabulary: &mut impl VocabularyMut<Iri = I, BlankId = B>, s: String, ) -> Id<I, B>

pub fn is_valid(&self) -> bool

Checks if this is a valid reference.

Returns true is this reference is a node identifier or a blank node identifier, false otherwise.

pub fn into_blank(self) -> Option<B>

pub fn is_blank(&self) -> bool

pub fn as_blank(&self) -> Option<&B>

pub fn is_iri(&self) -> bool

pub fn as_iri(&self) -> Option<&I>

pub fn into_term(self) -> Term<I, B>

pub fn as_ref(&self) -> Ref<'_, I, B>

pub fn map<J, C>(self, f: impl FnOnce(Id<I, B>) -> Id<J, C>) -> Id<J, C>

impl<I, B> Id<I, B>

where I: AsRef<str>, B: AsRef<str>,

pub fn as_str(&self) -> &str

Get a string representation of the reference.

This will either return a string slice of an IRI, or a blank node identifier.

Trait Implementations

impl<T, B, N> AsRefWithContext<str, N> for Id<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

fn as_ref_with<'a>(&'a self, vocabulary: &'a N) -> &'a str

impl<I, B> Clone for Id<I, B>

where I: Clone, B: Clone,

fn clone(&self) -> Id<I, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, B> Debug for Id<T, B>

where T: Debug, B: Debug,

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

Formats the value using the given formatter.

impl<T, B> Display for Id<T, B>

where T: Display, B: Display,

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

Formats the value using the given formatter.

impl<V> DisplayWithContext<V> for Id<<V as IriVocabulary>::Iri, <V as BlankIdVocabulary>::BlankId>

where V: IriVocabulary + BlankIdVocabulary,

fn fmt_with(&self, vocabulary: &V, f: &mut Formatter<'_>) -> Result<(), Error>

impl<I> Equivalent<Id<I>> for BlankId

fn equivalent(&self, key: &Id<I>) -> bool

Compare self to key and return true if they are equal.

impl<I> Equivalent<Id<I>> for BlankIdBuf

fn equivalent(&self, key: &Id<I>) -> bool

Compare self to key and return true if they are equal.

impl<I, B> Equivalent<Id<I, B>> for Id<I, B>

where I: PartialEq, B: PartialEq,

fn equivalent(&self, key: &Id<I, B>) -> bool

Compare self to key and return true if they are equal.

impl<'a, B> Equivalent<Id<IriBuf, B>> for &'a Iri

fn equivalent(&self, key: &Id<IriBuf, B>) -> bool

Compare self to key and return true if they are equal.

impl<B> Equivalent<Id<IriBuf, B>> for IriBuf

fn equivalent(&self, key: &Id<IriBuf, B>) -> bool

Compare self to key and return true if they are equal.

impl<'a, T, B> From<&'a Id<T, B>> for Id<&'a T, &'a B>

fn from(r: &'a Id<T, B>) -> Id<&'a T, &'a B>

Converts to this type from the input type.

impl<T, B> From<Id<T, B>> for Term<T, B>

fn from(prop: Id<T, B>) -> Term<T, B>

Converts to this type from the input type.

impl<T, B> From<T> for Id<T, B>

fn from(id: T) -> Id<T, B>

Converts to this type from the input type.

impl<T, B> From<Id<T, B>> for Id<T, B>

fn from(r: Id<T, B>) -> Id<T, B>

Converts to this type from the input type.

impl<I, B> Hash for Id<I, B>

where I: Hash, B: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, B, N> IntoJsonWithContext<N> for Id<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

fn into_json_with(self, context: &N) -> Value

impl<T, B> MappedEq for Id<T, B>

where T: PartialEq, B: PartialEq,

type BlankId = B

fn mapped_eq<'a, 'b, F>(&'a self, other: &Id<T, B>, f: F) -> bool

where F: Clone + Fn(&'a <Id<T, B> as MappedEq>::BlankId) -> &'b <Id<T, B> as MappedEq>::BlankId, <Id<T, B> as MappedEq>::BlankId: 'a + 'b,

Structural equality with mapped blank identifiers.

impl<I, B> Ord for Id<I, B>

where I: Ord, B: Ord,

fn cmp(&self, other: &Id<I, B>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<I, B> PartialEq<I> for Id<I, B>

where I: PartialEq,

fn eq(&self, other: &I) -> 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<T, B> PartialEq<Id<T, B>> for Term<T, B>

where T: PartialEq, B: PartialEq,

fn eq(&self, r: &Id<T, B>) -> 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<T, B> PartialEq<Term<T, B>> for Id<T, B>

where T: PartialEq, B: PartialEq,

fn eq(&self, term: &Term<T, B>) -> 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<T, B> PartialEq<str> for Id<T, B>

where T: PartialEq<str>, B: PartialEq<str>,

fn eq(&self, other: &str) -> 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<I, B> PartialEq for Id<I, B>

where I: PartialEq, B: PartialEq,

fn eq(&self, other: &Id<I, B>) -> 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<I, B> PartialOrd for Id<I, B>

where I: PartialOrd, B: PartialOrd,

fn partial_cmp(&self, other: &Id<I, B>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, B, N> PrecomputeSizeWithContext<N> for Id<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

fn contextual_pre_compute_size( &self, vocabulary: &N, _options: &Options, _sizes: &mut Vec<Size>, ) -> Size

impl<T, B, N> PrintWithContext<N> for Id<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

fn contextual_fmt_with( &self, vocabulary: &N, f: &mut Formatter<'_>, _options: &Options, _indent: usize, ) -> Result<(), Error>

impl<T, B, N> PrintWithSizeAndContext<N> for Id<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

fn contextual_fmt_with_size( &self, vocabulary: &N, f: &mut Formatter<'_>, _options: &Options, _indent: usize, _sizes: &[Size], _index: &mut usize, ) -> Result<(), Error>

impl<'a, T, B> TryFrom<&'a Id<T, B>> for &'a Id<T, B>

type Error = &'a String

The type returned in the event of a conversion error.

fn try_from( r: &'a Id<T, B>, ) -> Result<&'a Id<T, B>, <&'a Id<T, B> as TryFrom<&'a Id<T, B>>>::Error>

Performs the conversion.

impl<'a, T, B> TryFrom<&'a mut Id<T, B>> for &'a mut Id<T, B>

type Error = &'a mut String

The type returned in the event of a conversion error.

fn try_from( r: &'a mut Id<T, B>, ) -> Result<&'a mut Id<T, B>, <&'a mut Id<T, B> as TryFrom<&'a mut Id<T, B>>>::Error>

Performs the conversion.

impl<T, B> TryFrom<Id<T, B>> for Id<T, B>

type Error = String

The type returned in the event of a conversion error.

fn try_from( r: Id<T, B>, ) -> Result<Id<T, B>, <Id<T, B> as TryFrom<Id<T, B>>>::Error>

Performs the conversion.

impl<T, B> TryFrom<Term<T, B>> for Id<T, B>

type Error = Term<T, B>

The type returned in the event of a conversion error.

fn try_from(term: Term<T, B>) -> Result<Id<T, B>, Term<T, B>>

Performs the conversion.

impl<I, B> TryFromJson<I, B> for Id<I, B>

fn try_from_json_in( vocabulary: &mut impl VocabularyMut<Iri = I, BlankId = B>, value: Value, ) -> Result<Id<I, B>, InvalidExpandedJson>

impl<I, B> Eq for Id<I, B>

where I: Eq, B: Eq,

impl<I, B> StructuralPartialEq for Id<I, B>