Struct Processed

Source

pub struct Processed<'l, T = IriBuf, B = BlankIdBuf> {
    pub unprocessed: &'l Context,
    pub processed: Context<T, B>,
}

Expand description

An active context paired with a borrow of the @context it was built from.

Both halves are needed downstream: the active context drives expansion and compaction, while the original, syntactic context is what compaction embeds into its output so the result round-trips.

Derefs to the active context, so a caller that only needs that can use it directly.

Fields§

§unprocessed: &'l Context

The context as it was written.

§processed: Context<T, B>

The active context it processed into.

Implementations§

Source §

impl<'l, T, B> Processed<'l, T, B>

Source

pub fn new(unprocessed: &'l Context, processed: Context<T, B>) -> Self

Pairs an active context with the @context it was built from.

Source

pub fn unprocessed(&self) -> &'l Context

Returns the @context as it was written, before processing.

Source

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

Discards the original @context and returns just the active context.

Source

pub fn as_ref(&self) -> ProcessedRef<'l, '_, T, B>

Borrows both halves as a ProcessedRef.

Source

pub fn into_owned(self) -> ProcessedOwned<T, B>

Clones the original @context so the pair no longer borrows it.

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

Source

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.

Source

pub fn processing_mode(&self) -> ProcessingMode

Returns the processing mode this context was processed under.

Source

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

Sets the processing mode of this context.

Source

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.

Source

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.

Source

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

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

Source

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.

Source

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

Returns the original base URL of the context.

Source

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

Returns the base IRI of the context.

Source

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

Returns the @vocab value, if any.

Source

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

Returns the default @language value.

Source

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

Returns the default @direction value.

Source

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

Returns a reference to the previous context.

Source

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.

Source

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.

Source

pub fn len(&self) -> usize

Returns the number of terms defined.

Source

pub fn is_empty(&self) -> bool

Checks if no terms are defined.

Source

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

Returns a handle to the term definitions.

Source

pub fn has_protected_items(&self) -> bool

Checks if the context has a protected definition.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source