Struct ReadOnlyNetwork 

pub struct ReadOnlyNetwork { /* private fields */ }

Compile-time read-only view over a shared links network.

ReadOnlyNetwork derefs to &LinkNetwork, so every non-mutating public operation is reachable while the &mut self mutators (insert_link, set_references, set_span, set_flags, apply_substitution, …) are unreachable: there is no DerefMut, so the borrow checker rejects any attempt to call them. The wrapped network is held behind an Arc, so cloning a view shares one allocation rather than copying the network.

Read-only operations compile and run:

use meta_language::{LinkNetwork, ParseConfiguration};

let view = LinkNetwork::parse("alpha", "plain-text", ParseConfiguration::default()).freeze();
assert_eq!(view.reconstruct_text(), "alpha");

Mutation does not compile, because the mutators require &mut LinkNetwork and the view only ever yields &LinkNetwork:

use meta_language::{LinkMetadata, LinkNetwork, ParseConfiguration};

let view = LinkNetwork::parse("alpha", "plain-text", ParseConfiguration::default()).freeze();
view.insert_link([], LinkMetadata::new()); // error: cannot borrow as mutable

Implementations

impl ReadOnlyNetwork

pub fn new(network: LinkNetwork) -> Self

Freezes an owned network into a read-only view.

pub const fn from_shared(network: Arc<LinkNetwork>) -> Self

Wraps an already shared network as a read-only view.

This reuses the existing allocation, allowing read-only access to compose with snapshot versioning without re-cloning the network.

pub fn network(&self) -> &LinkNetwork

Borrows the underlying immutable network.

pub const fn shared(&self) -> &Arc<LinkNetwork>

Borrows the shared network handle.

pub fn into_shared(self) -> Arc<LinkNetwork>

Consumes the view and returns the shared network handle.

pub fn shared_count(&self) -> usize

Number of handles sharing the frozen network allocation.

pub fn to_mutable(&self) -> LinkNetwork

Forks an editable copy so callers can return to a mutable engine.

pub fn into_mutable(self) -> LinkNetwork

Consumes the view and returns an editable network, reusing the allocation when this is the only handle and cloning otherwise.

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 ReadOnlyNetwork

fn clone(&self) -> ReadOnlyNetwork

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReadOnlyNetwork

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

Formats the value using the given formatter.

impl Deref for ReadOnlyNetwork

type Target = LinkNetwork

The resulting type after dereferencing.

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

Dereferences the value.

impl From<LinkNetwork> for ReadOnlyNetwork

fn from(network: LinkNetwork) -> Self

Converts to this type from the input type.

impl LinkStore for ReadOnlyNetwork

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 ReadOnlyNetwork

fn eq(&self, other: &Self) -> 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 ReadOnlyNetwork