Enum ContextRef 

pub enum ContextRef<'a, T = IriBuf, B = BlankIdBuf> {
    Borrowed(&'a Context<T, B>),
    Owned(Box<Context<T, B>>),
}

Either a borrowed context or an owned one held behind a box.

Expansion and compaction repeatedly rebind an active context that may or may not have been replaced by a processed one. A Cow-like type is the natural fit, but Context is over 250 bytes and storing it inline makes every async state machine holding one that much larger — the value is memmoved on every recursion. Boxing the owned arm keeps this two words wide however Context grows, at the cost of one allocation on a path that has just built a whole context anyway.

Variants

Borrowed(&'a Context<T, B>)

Borrowed from the caller.

Owned(Box<Context<T, B>>)

Owned by this value.

Implementations

impl<T, B> ContextRef<'_, T, B>

pub fn owned(context: Context<T, B>) -> Self

Takes ownership of context, boxing it.

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

Borrows the context, whichever arm holds it.

pub fn is_owned(&self) -> bool

Returns true if the context is owned.

Expansion uses this to detect that scoped-context processing replaced the active context, and that cached key expansions must be recomputed.

Methods from Deref<Target = Context<T, B>>

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 get<Q>(&self, term: &Q) -> Option<TermDefinitionRef<'_, T, B>>

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

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: ?Sized + Hash + Eq,

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: ?Sized + Hash + Eq,

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<&Self>

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 Self

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) -> &[PrefixTerm<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<CompactIriKey<T, B>, 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: FnOnce() -> KeywordAliases>( &self, mode: ProcessingMode, init: F, ) -> &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.

Trait Implementations

impl<T, B> Deref for ContextRef<'_, T, B>

type Target = Context<T, B>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.