Struct Context 

pub struct Context<T = Iri<String>, B = BlankIdBuf> { /* private fields */ }

Active context: everything the algorithms need to expand or compact against the current scope.

Implementations

impl<T, B> Context<T, B>

pub fn new(base_iri: Option<T>) -> Context<T, B>

where T: Clone,

Create a new context with the given base IRI.

pub fn with_private_caches(&self) -> Context<T, B>

where T: Clone, B: Clone,

Returns a copy of this context whose IRI memoisation caches are private to the copy.

Self::term_resolution_cache maps a term to an already-resolved Term, which carries T-typed identifiers. Sharing it across vocabulary forks is unsound: a term that one fork resolved by interning a new IRI would be served to another fork, where that identifier denotes something else entirely — or nothing. Concurrent expansion therefore gives each task a context of its own.

Only the caches are fresh. Definitions, prefix terms and keyword aliases are shared through their Arcs: they are derived from the context’s own definitions, whose identifiers every fork inherits, so they stay valid. The same reasoning covers the inverse context.

pub fn processing_mode(&self) -> ProcessingMode

Returns the processing mode this context was processed under.

pub fn set_processing_mode(&mut self, mode: ProcessingMode)

Sets the processing mode of this context.

pub fn get<Q>(&self, term: &Q) -> Option<TermDefinitionRef<'_, T, B>>

where Key: Borrow<Q>, KeywordType: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the given term definition, if any.

pub fn get_normal<Q>(&self, term: &Q) -> Option<&NormalTermDefinition<T, B>>

where Key: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the given term normal definition, if any.

pub fn get_type(&self) -> Option<&TypeTermDefinition>

Returns a reference to the @type definition, if any.

pub fn contains_term<Q>(&self, term: &Q) -> bool

where Key: Borrow<Q>, KeywordType: Borrow<Q>, Q: Hash + Eq + ?Sized,

Checks if the given term is defined.

pub fn original_base_url(&self) -> Option<&T>

Returns the original base URL of the context.

pub fn base_iri(&self) -> Option<&T>

Returns the base IRI of the context.

pub fn vocabulary(&self) -> Option<&Term<T, B>>

Returns the @vocab value, if any.

pub fn default_language(&self) -> Option<&LenientLangTag>

Returns the default @language value.

pub fn default_base_direction(&self) -> Option<Direction>

Returns the default @direction value.

pub fn previous_context(&self) -> Option<&Context<T, B>>

Returns a reference to the previous context.

pub fn definitions_arc_ptr(&self) -> *const Definitions<T, B>

Returns the address of the Arc backing the term definitions.

Two contexts that share this pointer share the exact same definitions (copy-on-write via Arc::make_mut). Useful as a cheap fingerprint for memoization keys.

pub fn previous_context_arc_ptr(&self) -> *const Context<T, B>

Returns the address of the Arc backing the previous context, or null when there is none. See Self::definitions_arc_ptr.

pub fn len(&self) -> usize

Returns the number of terms defined.

pub fn is_empty(&self) -> bool

Checks if no terms are defined.

pub fn definitions(&self) -> &Definitions<T, B>

Returns a handle to the term definitions.

pub fn has_protected_items(&self) -> bool

Checks if the context has a protected definition.

pub fn inverse(&self) -> &InverseContext<T, B>

where T: Clone + Hash + Eq, B: Clone + Hash + Eq,

Returns the inverse context, computing and caching it on first access.

pub fn prefix_terms(&self) -> &[(Key, Arc<Term<T, B>>)]

Returns the term definitions whose prefix flag is true, each paired with its IRI mapping.

The mapping is carried alongside the key so that compaction’s candidate loop does not have to look the definition back up — which would re-hash the very key this list just handed it. Definitions with no IRI mapping cannot form a compact IRI and are left out.

Lazily computed and cached; invalidated whenever a definition is added, removed, or replaced.

pub fn compact_iri_cache( &self, ) -> &ShardedMemo<(Term<T, B>, bool, bool, ProcessingMode), Option<Arc<str>>>

Returns the per-context memoization map for the compact-IRI algorithm.

The cache stores results keyed on (var, vocab, reverse, mode). It is invalidated whenever the context’s term definitions, base IRI, vocabulary, language, or direction change, since those affect compaction output.

pub fn term_resolution_cache(&self) -> &ShardedMemo<Box<str>, Arc<Term<T, B>>>

Returns the per-context memoization map for IRI expansion of term keys.

Maps the input string to the resolved Arc<Term>. Populated only by the dominant key-expansion call shape (vocab=Some(Keep), document_relative=false); other shapes bypass this cache. Invalidated alongside the compact-IRI / inverse caches whenever the context’s term definitions, base IRI, vocabulary, language, or direction change.

pub fn keyword_aliases_or_init<F>( &self, mode: ProcessingMode, init: F, ) -> &KeywordAliases

where F: FnOnce() -> KeywordAliases,

Returns the cached keyword aliases of this context for the given processing mode, computing them via init on first access. The closure runs once per (context, mode); subsequent calls return the cached value. Aliases are cached per mode because compact-IRI selection is mode-dependent.

pub fn set_normal( &mut self, key: Key, definition: Option<NormalTermDefinition<T, B>>, ) -> Option<NormalTermDefinition<T, B>>

where T: Clone, B: Clone,

Sets the normal definition for the given term key.

pub fn set_type( &mut self, type_: Option<TypeTermDefinition>, ) -> Option<TypeTermDefinition>

where T: Clone, B: Clone,

Sets the @type definition.

pub fn set_base_iri(&mut self, iri: Option<T>)

Sets the base IRI.

pub fn set_vocabulary(&mut self, vocab: Option<Term<T, B>>)

Sets the @vocab value.

pub fn set_default_language(&mut self, lang: Option<LenientLangTagBuf>)

Sets the default @language value.

pub fn set_default_base_direction(&mut self, dir: Option<Direction>)

Sets the default @direction value.

pub fn set_previous_context(&mut self, previous: Context<T, B>)

Sets the previous context.

pub fn into_syntax_definition( self, vocabulary: &impl Vocabulary<Iri = T, BlankId = B>, ) -> Result<Definition, InvalidContextError>

where T: Clone, B: Clone,

Converts this context into its syntactic definition.

Errors

Returns an error when a term in the context cannot be represented in syntax form, which happens if the vocabulary has no IRI for an identifier it holds.

pub fn map_ids<U, C>( self, map_iri: impl FnMut(T) -> U, map_id: impl FnMut(ValidId<T, B>) -> ValidId<U, C>, ) -> Context<U, C>

where T: Clone, B: Clone,

Rewrites every IRI and identifier of this context with the given functions.

Trait Implementations

impl<T, B> Clone for Context<T, B>

where T: Clone, B: Clone,

fn clone(&self) -> Context<T, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, B> Default for Context<T, B>

fn default() -> Context<T, B>

Returns the “default value” for a type.

impl<T, B> IntoSyntax<T, B> for Context<T, B>

where T: Clone, B: Clone,

fn into_syntax( self, vocabulary: &impl Vocabulary<Iri = T, BlankId = B>, ) -> Result<Context, InvalidContextError>

Consumes this value, returning the equivalent syntactic context. The given vocabulary must be the one the context was built with, so its IRI handles can be resolved back to actual IRIs.

impl<T, B> PartialEq for Context<T, B>

where T: PartialEq, B: PartialEq,

fn eq(&self, other: &Context<T, B>) -> bool

Equality operator ==.

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

Inequality operator !=.