Struct LinkNetwork 

pub struct LinkNetwork { /* private fields */ }

Mutable links network for CST, AST, semantic, and self-description links.

Implementations

impl LinkNetwork

pub fn freeze(self) -> ReadOnlyNetwork

Freezes this network into a read-only view, consuming it.

Mutators are unreachable on the returned ReadOnlyNetwork at compile time; only &self operations remain available.

pub fn as_read_only(&self) -> ReadOnlyNetwork

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

pub fn parse_engine( text: &str, language: &str, configuration: ParseConfiguration, ) -> EngineNetwork

Parses source text honouring the configured engine access mode.

Under AccessMode::Mutable (the default) this returns an editable network; under AccessMode::ReadOnly it returns the frozen form, where mutation attempts at the engine boundary fail with a clear diagnostic.

impl LinkNetwork

pub fn parse_fluent( text: &str, language: &str, configuration: ParseConfiguration, ) -> FluentPipeline

Parses source text and starts a fluent chain.

pub fn apply_link_cli_substitution_text( &mut self, source: &str, ) -> Result<SubstitutionReport, LinkCliSubstitutionError>

Applies a link-cli-style substitution command.

Errors

Returns LinkCliSubstitutionError when the command text is malformed.

impl LinkNetwork

pub fn seed_common_concept_ontology(&mut self) -> ConceptOntologySeedReport

Seeds the network with the shared common concept ontology.

The seed combines meta-expression’s semantic lexicon with structural programming-language concepts that are shared across the current language targets.

pub fn intern_concept( &mut self, exact_id: &str, definition: Option<&str>, ) -> LinkId

Interns a language-free concept by exact identifier.

The identifier is matched exactly: case changes, diacritic changes, or sense suffixes are distinct concept ids and therefore produce distinct concept links.

pub fn insert_concept_expression( &mut self, concept: &str, language: &str, expression: &str, ) -> LinkId

Inserts a language-bound expression linked to a language-free concept.

The concept is reused only when concept exactly matches an existing concept id; otherwise a new concept link is minted.

pub fn insert_concept_mapping( &mut self, concept: &str, language: &str, syntax: &str, ) -> LinkId

Inserts a concept-to-language syntax mapping and returns the semantic link id.

pub fn insert_concept_alias( &mut self, concept_link: LinkId, vocabulary: &str, external_id: &str, ) -> LinkId

Attaches an external vocabulary id to a concept without changing its exact concept id.

pub fn import_concept_ontology_lino( &mut self, text: &str, ) -> Result<ConceptOntologyImportReport, LinoSerializationError>

Imports concept, expression, and alias links from canonical LiNo text.

The input is the links-notation text produced by LinkNetwork::to_lino. Importing the same text repeatedly is idempotent because concepts, expressions, and aliases are all deduplicated by exact link shape.

impl LinkNetwork

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.

impl LinkNetwork

pub fn seed_document_formatting_concepts( &mut self, ) -> DocumentFormattingSeedReport

Seeds the shared document-formatting concept set with per-format syntax mappings.

Each concept becomes a language-free LinkType::Concept link, and each (language, template) pair becomes a semantic syntax mapping so the same concept reconstructs as **…** in Markdown, <strong>…</strong> in HTML, and so on.

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.

impl LinkNetwork

pub fn apply_edit(&mut self, range: ByteRange, replacement: &str) -> bool

Applies a byte-range source edit and reparses the network.

Tree-sitter-backed languages use tree-sitter’s incremental parse path; other languages fall back to the built-in lossless parser. Links whose source spans are outside the replaced byte range keep their identifiers.

pub fn apply_edit_with_configuration( &mut self, range: ByteRange, replacement: &str, configuration: ParseConfiguration, ) -> bool

Applies a byte-range source edit using an explicit parse configuration.

Returns false when the range is outside the reconstructed source text, splits a UTF-8 code point, or the network has no document language.

impl LinkNetwork

pub const fn new() -> Self

Creates an empty links network.

pub fn self_describing() -> Self

Creates a links network containing the common self-description roots.

pub fn self_description_text(&self) -> String

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

pub fn parse( text: &str, language: &str, configuration: ParseConfiguration, ) -> Self

Parses plain source text into a lossless token network.

This is the default parse operation. It is lossless by construction; use LinkNetwork::projected_links when a lower-level view should be stripped away for CST, AST, or semantic-only work.

pub fn parse_lossless_text( text: &str, language: &str, configuration: ParseConfiguration, ) -> Self

Parses plain source text into a lossless token network.

This parser boundary preserves source spans, trivia links, recovery markers, and mixed-region metadata behind the same network representation.

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 insert_point(&mut self, term: &str) -> LinkId

Inserts a self-referential point link for a term.

pub fn insert_object(&mut self, term: &str) -> LinkId

Inserts an object-identity point link.

pub fn insert_relation<const N: usize>( &mut self, references: [LinkId; N], link_type: LinkType, span: SourceSpan, ) -> LinkId

Inserts a relation link with source span metadata.

pub fn insert_field( &mut self, parent: LinkId, label: &str, child: LinkId, ) -> LinkId

Inserts a labeled field relation as a regular link.

pub fn insert_link<const N: usize>( &mut self, references: [LinkId; N], metadata: LinkMetadata, ) -> LinkId

Inserts a link from references and metadata.

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

Reconstructs a concept using a target language syntax mapping.

pub fn apply_substitution( &mut self, rule: &SubstitutionRule, ) -> SubstitutionReport

Applies a match-and-substitute rule over exact reference lists.

pub fn apply_variable_substitution( &mut self, rule: &VariableSubstitutionRule, ) -> SubstitutionReport

Applies a match-and-substitute rule with link-cli-style variables.

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 set_span(&mut self, id: LinkId, span: SourceSpan) -> bool

Sets a source span on an existing link.

pub fn set_flags(&mut self, id: LinkId, flags: LinkFlags) -> bool

Sets parse flags on an existing link.

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

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

impl LinkNetwork

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 from_lino(text: &str) -> Result<Self, LinoSerializationError>

Reconstructs a network from text produced by LinkNetwork::to_lino.

Errors

Returns LinoSerializationError when the text is not valid links-notation or does not match the serialization schema.

impl LinkNetwork

pub fn parse_with_registry( registry: &ParserRegistry, text: &str, language: &str, configuration: ParseConfiguration, ) -> Self

Parses source text through a pluggable ParserRegistry.

Dispatch honors user registrations, which shadow the built-in set for the same language key; keys without an explicit registration fall through to the same built-in dispatch LinkNetwork::parse uses.

impl LinkNetwork

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 reconstruct_text_as_with_rules_mut( &mut self, target_language: &str, configuration: ParseConfiguration, rule_set: &TranslationRuleSet, ) -> String

Reconstructs text and records diagnostic links when no rule can render it.

impl LinkNetwork

pub fn insert_object_instance(&mut self, type_id: LinkId) -> LinkId

Inserts an anonymous object identity linked to its Rust/meta type.

The resulting object references itself first, preserving a stable identity link for shared and circular object graphs, and references the type shape second so the object’s declaration remains queryable.

impl LinkNetwork

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.

impl LinkNetwork

pub fn insert_source_token(&mut self, language: &str, text: &str) -> LinkId

Inserts a source token that can be rendered without an original source span.

This is the construction-side counterpart to parser-created token links: the token text is stored in the link term, but no byte range is required.

pub fn insert_syntax_node<const N: usize>( &mut self, language: &str, kind: &str, children: [LinkId; N], ) -> LinkId

Inserts a syntax node whose ordered references are renderable children.

The kind should match the grammar node vocabulary used by the corresponding parser where possible. Rendering only emits descendant token text; the kind is metadata for queries and round-trip validation.

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.

impl LinkNetwork

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.

pub fn replace( &mut self, matches: &[QueryMatch], rule: &ReplacementRule, ) -> ReplacementReport

Applies a replacement rule to links selected by LinkNetwork::find.

pub fn replace_with_profile( &mut self, matches: &[QueryMatch], rule: &ReplacementRule, profile: &LanguageProfile, ) -> ReplacementReport

Applies a replacement only when the result stays inside a language profile.

The replacement is first evaluated on a cloned network. If the candidate network validates against the profile, it is committed to self. If the profile rejects it, self keeps its original source text and receives a queryable language-profile:unsupported-feature diagnostic link.

Trait Implementations

impl Clone for LinkNetwork

fn clone(&self) -> LinkNetwork

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinkNetwork

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

Formats the value using the given formatter.

impl Default for LinkNetwork

fn default() -> LinkNetwork

Returns the “default value” for a type.

impl FluentNetworkApi for LinkNetwork

fn into_network(self) -> LinkNetwork

Converts self into the underlying network executor.

fn into_fluent(self) -> FluentPipeline

Starts a fluent chain over the same network executor.

impl From<LinkNetwork> for ReadOnlyNetwork

fn from(network: LinkNetwork) -> Self

Converts to this type from the input type.

impl LinkStore for LinkNetwork

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 LinkNetwork

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

impl StructuralPartialEq for LinkNetwork