Enum json_ld::Id

pub enum Id<I = IriBuf, B = BlankIdBuf> {
    Valid(Subject<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 [hashbrown::Equivalent<Id<I, B>>] implementation.

Variants

Valid(Subject<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>

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 copy 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<T, B, N> DisplayWithContext<N> for Id<T, B>where
    N: Vocabulary<Iri = T, BlankId = B>,

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

impl<I, B> Equivalent<Id<I, B>> for Subject<I, B>where
    I: PartialEq<I>,
    B: PartialEq<B>,

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

Checks if this value is equivalent to the given key.

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

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

Checks if this value is equivalent to the given key.

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<Subject<T, B>> for Id<T, B>

fn from(r: Subject<T, B>) -> Id<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<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, M, N> IntoJsonWithContextMeta<M, N> for Id<T, B>where
    N: Vocabulary<Iri = T, BlankId = B>,

fn into_json_meta_with(self, meta: M, context: &N) -> Meta<Value<M>, M>

impl<T, B> MappedEq<Id<T, B>> for Id<T, B>where
    T: PartialEq<T>,
    B: PartialEq<B>,

type BlankId = B

fn mapped_eq<'a, 'b, F>(&'a self, other: &Id<T, B>, f: F) -> boolwhere
    F: Clone + Fn(&'a <Id<T, B> as MappedEq<Id<T, B>>>::BlankId) -> &'b <Id<T, B> as MappedEq<Id<T, B>>>::BlankId,
    <Id<T, B> as MappedEq<Id<T, B>>>::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) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

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

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

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

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

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method 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, Global>
) -> 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<I, B> StrippedHash for Id<I, B>where
    I: Hash,
    B: Hash,

fn stripped_hash<H>(&self, state: &mut H)where
    H: Hasher,

impl<I, B, __I, __B> StrippedPartialEq<Id<__I, __B>> for Id<I, B>where
    I: PartialEq<__I>,
    B: PartialEq<__B>,

fn stripped_eq(&self, other: &Id<__I, __B>) -> bool

impl<'a, T, B> TryFrom<&'a Id<T, B>> for &'a Subject<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 Subject<T, B>, <&'a Subject<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 Subject<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 Subject<T, B>, <&'a mut Subject<T, B> as TryFrom<&'a mut Id<T, B>>>::Error>

Performs the conversion.

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

type Error = String

The type returned in the event of a conversion error.

fn try_from(
    r: Id<T, B>
) -> Result<Subject<T, B>, <Subject<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, M> TryFromJson<I, B, M> for Id<I, B>

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

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

impl<I, B> StrippedEq for Id<I, B>where
    I: Eq,
    B: Eq,

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

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