Enum json_ld::Lexicon

pub enum Lexicon<V: Vocab> {
    Id(V),
    Iri(IriBuf),
}

Lexicon identifier.

A Lexicon is a special identifier type (Id) built from a Vocab (vocabulary) type. While Vocab represents only a subset of all the possible IRIs, this type can also hold any IRI outside of the predefined vocabulary. It is a simple way to get an identifier type from a vocabulary.

Example

The following example builds a lexicon from a statically known vocabulary, defined as an enum type. It uses the iref-enum crate to automatically derive the convertion of the Vocab type from/into IRIs.

use iref_enum::*;
use json_ld::Lexicon;
use serde_json::Value;

/// Vocabulary used in the implementation.
#[derive(IriEnum, Clone, Copy, PartialEq, Eq, Hash)]
#[iri_prefix("rdfs" = "http://www.w3.org/2000/01/rdf-schema#")]
#[iri_prefix("manifest" = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#")]
#[iri_prefix("vocab" = "https://w3c.github.io/json-ld-api/tests/vocab#")]
pub enum Vocab {
    #[iri("rdfs:comment")] Comment,

    #[iri("manifest:name")] Name,
    #[iri("manifest:entries")] Entries,
    #[iri("manifest:action")] Action,
    #[iri("manifest:result")] Result,

    #[iri("vocab:PositiveEvaluationTest")] PositiveEvalTest,
    #[iri("vocab:NegativeEvaluationTest")] NegativeEvalTest,
    #[iri("vocab:option")] Option,
    #[iri("vocab:specVersion")] SpecVersion,
    #[iri("vocab:processingMode")] ProcessingMode,
    #[iri("vocab:expandContext")] ExpandContext,
    #[iri("vocab:base")] Base
}

/// A fully functional identifier type.
pub type Id = Lexicon<Vocab>;

fn handle_node(node: &json_ld::Node<Value, Id>) {
  for name in node.get(Vocab::Name) { // <- note that we can directly use `Vocab` here.
    println!("node name: {}", name.as_str().unwrap());
  }
}

Variants

Id(V)

Identifier from the known vocabulary.

Iri(IriBuf)

Any other IRI outside of the vocabulary.

Trait Implementations

impl<V: Vocab> AsIri for Lexicon<V>

fn as_iri(&self) -> Iri<'_>

impl<V: Clone + Vocab> Clone for Lexicon<V>

fn clone(&self) -> Lexicon<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Vocab> Display for Lexicon<V>

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

Formats the value using the given formatter.

impl<V: Hash + Vocab> Hash for Lexicon<V>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<V: Vocab> Id for Lexicon<V>

fn from_iri(iri: Iri<'_>) -> Lexicon<V>

Create an identifier from its IRI.

fn as_json<K: JsonBuild>(&self, meta: K::MetaData) -> K

impl<V: PartialEq + Vocab> PartialEq<Lexicon<V>> for Lexicon<V>

fn eq(&self, other: &Lexicon<V>) -> bool

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

fn ne(&self, other: &Lexicon<V>) -> bool

This method tests for !=.

impl<V: Vocab> PartialEq<V> for Lexicon<V>

fn eq(&self, other: &V) -> 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 !=.

impl<V: Vocab> ToReference<Lexicon<V>> for V

type Reference = Reference<Lexicon<V>>

The target type of the conversion, which can be borrowed as a Reference<T>.

fn to_ref(&self) -> Self::Reference

Convert the value into a reference.

impl<V: Eq + Vocab> Eq for Lexicon<V>

impl<V: Vocab> StructuralEq for Lexicon<V>

impl<V: Vocab> StructuralPartialEq for Lexicon<V>