Enum EngineNetwork 

pub enum EngineNetwork {
    Mutable(LinkNetwork),
    ReadOnly(ReadOnlyNetwork),
}

Access-mode-aware engine handle returned by configured parsing.

This is the runtime boundary where the configured AccessMode is enforced: a read-only engine yields a frozen view and rejects EngineNetwork::as_mutable with a ReadOnlyViolation, while a mutable engine hands back the editable network.

Variants

Mutable(LinkNetwork)

An editable network produced under AccessMode::Mutable.

ReadOnly(ReadOnlyNetwork)

A frozen view produced under AccessMode::ReadOnly.

Implementations

impl EngineNetwork

pub fn with_access_mode(network: LinkNetwork, access_mode: AccessMode) -> Self

Wraps a network according to the supplied access mode.

pub const fn access_mode(&self) -> AccessMode

The access mode this handle was created with.

pub const fn is_mutable(&self) -> bool

Whether this handle permits mutation.

pub const fn is_read_only(&self) -> bool

Whether this handle is read-only.

pub fn network(&self) -> &LinkNetwork

Borrows the underlying network for read-only operations regardless of the access mode.

pub fn as_mutable(&mut self) -> Result<&mut LinkNetwork, ReadOnlyViolation>

Borrows the network mutably, or fails with a clear diagnostic when the engine is read-only.

Errors

Returns ReadOnlyViolation when this handle was created under AccessMode::ReadOnly.

pub fn into_read_only(self) -> ReadOnlyNetwork

Converts this handle into a read-only view, freezing a mutable network.

pub fn into_mutable(self) -> LinkNetwork

Converts this handle into an editable network, forking a read-only view.

Methods from Deref<Target = LinkNetwork>

pub fn as_read_only(&self) -> ReadOnlyNetwork

Returns a read-only view sharing a clone of this network.

pub fn render_markup_document( &self, language: &str, document: &FormattingDocument, ) -> String

Renders a language-free FormattingDocument (the concept layer) into language surface syntax using the seeded per-format templates.

pub fn translate_markup_document( &self, source_language: &str, target_language: &str, text: &str, ) -> Option<String>

Parses text written in source_language into the language-free concept layer, then renders it as target_language surface syntax.

This is the cross-format reconstruction substrate: a Markdown document using bold/italic/heading/list/link round-trips to HTML and back through the shared concept ontology.

pub fn resolve_document_format( &self, language: &str, fragment: &str, ) -> Option<DocumentFormatMatch>

Resolves a formatting fragment written in language to the shared, language-free concept it denotes.

Both Markdown **bold** and HTML <strong>bold</strong> resolve to the one seeded strong concept link. Returns None when the fragment is not a known formatting construct or the concept set has not been seeded.

pub fn render_document_format( &self, concept: &str, language: &str, instance: &DocumentFormatInstance, ) -> Option<String>

Renders a concept instance into language surface syntax.

Returns None when the concept has no template for the language or a required attribute is missing from the instance.

pub fn translate_document_format( &self, source_language: &str, target_language: &str, fragment: &str, ) -> Option<String>

Translates a single formatting fragment from source_language to target_language through the shared concept layer.

pub fn document_formatting_concept(&self, concept: &str) -> Option<LinkId>

Returns the seeded concept link for a formatting concept id, when present.

pub fn self_description_text(&self) -> String

Serializes the seeded self-description roots as LiNo-style definition lines.

pub fn len(&self) -> usize

Number of links in the network.

pub fn is_empty(&self) -> bool

Whether the network contains no links.

pub fn shared_link_count(&self, id: LinkId) -> Option<usize>

Number of network handles sharing one immutable link allocation.

pub fn interned_string_count(&self, value: &str) -> Option<usize>

Number of internal handles sharing an interned string value.

pub fn links(&self) -> impl Iterator<Item = &Link>

Iterates over links in identifier order.

pub fn projected_links( &self, projection: NetworkProjection, ) -> impl Iterator<Item = &Link>

Iterates over links included in the selected projection.

pub fn reconstruct_text(&self) -> String

Reconstructs source text from non-missing token links ordered by span.

pub fn embedded_regions(&self) -> Vec<EmbeddedRegion>

Returns embedded mixed-language regions discovered during parse.

pub fn query_links(&self, query: &LinkQuery) -> Vec<&Link>

Returns links matching a structural query.

pub fn query_matches(&self, query: &LinkQuery) -> Vec<QueryMatch>

Returns query matches with capture bindings.

pub fn query_matches_with( &self, query: &LinkQuery, predicate_host: &impl QueryPredicateHost, ) -> Vec<QueryMatch>

Returns query matches with host-evaluated predicate support.

pub fn reconstruct_concept(&self, concept: &str, language: &str) -> Option<&str>

Reconstructs a concept using a target language syntax mapping.

pub fn link(&self, id: LinkId) -> Option<&Link>

Returns a link by id.

pub fn find_term(&self, term: &str) -> Option<LinkId>

Finds a self-description or named term link.

pub fn definition_for(&self, id: LinkId) -> Option<&str>

Finds the definition attached to a term link.

pub fn verify_full_match(&self, region: Option<ByteRange>) -> VerificationReport

Verifies that the selected region has no error or missing links.

pub fn to_lino(&self) -> String

Serializes the entire network to canonical links-notation text.

Every link becomes one statement keyed by its numeric id. The output is accepted by the [links_notation] crate parser and round-trips back through LinkNetwork::from_lino.

pub fn reconstruct_text_as( &self, target_language: &str, configuration: ParseConfiguration, ) -> String

Reconstructs text for a target language or formalization level.

Natural same-language reconstruction returns the original byte-exact token stream. When semantic proposition links are available, target natural-language text and configured formal representations are rendered through the shared concept mappings.

pub fn reconstruct_text_as_with_rules( &self, target_language: &str, configuration: ParseConfiguration, rule_set: &TranslationRuleSet, ) -> String

Reconstructs text using a caller-supplied translation rule set.

pub fn reconstruct_text_as_with_registry( &self, target_language: &str, configuration: ParseConfiguration, registry: &TranslationRuleRegistry, ) -> String

Reconstructs text through the active rule set in a registry.

pub fn snapshot( &self, version: u64, provenance: impl Into<String>, ) -> NetworkSnapshot

Captures the current network as an immutable versioned snapshot.

pub fn structural_diff(&self, other: &Self) -> StructuralDiff

Computes changed, added, and removed link ids against another network.

pub fn render_source(&self, language: &str) -> String

Renders source text for language from a parsed or constructed network.

Parsed networks are rendered from their document root. Hand-built networks without document links are rendered from top-level syntax or token links whose metadata language matches language.

pub fn render_source_from(&self, root: LinkId, language: &str) -> String

Renders source text from a specific syntax, document, region, or token link.

pub fn render_source_from_document(&self, language: &str) -> Option<String>

Renders source text from document links matching language.

Returns None when the network has no matching document link, which is common for programmatically constructed syntax fragments.

pub fn find(&self, query: &LinkQuery) -> Vec<QueryMatch>

Finds query matches using the transform surface’s source-text predicates.

This delegates structural matching to LinkQuery’s S-expression matcher. Built-in predicates such as #eq? @capture "text" compare the text reconstructed from captured token links.

Trait Implementations

impl Clone for EngineNetwork

fn clone(&self) -> EngineNetwork

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngineNetwork

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

Formats the value using the given formatter.

impl Deref for EngineNetwork

type Target = LinkNetwork

The resulting type after dereferencing.

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

Dereferences the value.

impl LinkStore for EngineNetwork

fn create( &mut self, references: &[LinkId], metadata: LinkMetadata, ) -> Result<LinkId, StorageError>

Creates a link and returns its stable id.

fn read(&self, id: LinkId) -> Result<Option<Link>, StorageError>

Reads a link by id.

fn update( &mut self, id: LinkId, references: &[LinkId], metadata: LinkMetadata, ) -> Result<bool, StorageError>

Replaces an existing link’s references and metadata.

fn delete(&mut self, id: LinkId) -> Result<bool, StorageError>

Deletes a link by id.

fn search(&self, query: &LinkStoreQuery) -> Result<Vec<Link>, StorageError>

Returns links matching query.

fn count(&self, query: &LinkStoreQuery) -> Result<usize, StorageError>

Counts links matching query.

impl PartialEq for EngineNetwork

fn eq(&self, other: &EngineNetwork) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for EngineNetwork

impl StructuralPartialEq for EngineNetwork