Struct ParserRegistry 

pub struct ParserRegistry { /* private fields */ }

A pluggable dispatch table mapping language keys to LanguageParsers.

The registry starts with the BuiltInLanguageParser as a fallback, so an unmodified registry behaves exactly like LinkNetwork::parse: lino is handled by the links-notation parser and every other key is routed through the tree-sitter adapter with a lossless text fallback.

Users register parsers for new language keys or override an existing one. Following TXL’s grammar-override model and SWC’s plugin lesson, a user registration shadows the built-in dispatch for the same key rather than forking the pipeline: any key without an explicit registration still falls through to the built-in set.

Language keys are matched case-insensitively, mirroring the built-in dispatch (LINO, Lino, and lino resolve to the same parser).

Examples

use std::sync::Arc;
use meta_language::{
    LanguageParser, LinkNetwork, ParseConfiguration, ParserRegistry,
};

#[derive(Debug)]
struct ShoutParser;

impl LanguageParser for ShoutParser {
    fn parse_source(
        &self,
        text: &str,
        language: &str,
        configuration: ParseConfiguration,
    ) -> LinkNetwork {
        LinkNetwork::parse_lossless_text(&text.to_uppercase(), language, configuration)
    }
}

let registry = ParserRegistry::new().with_parser("shout", Arc::new(ShoutParser));
let network = registry.parse("hi", "shout", ParseConfiguration::default());
assert_eq!(network.reconstruct_text(), "HI");

Implementations

impl ParserRegistry

pub fn new() -> Self

Creates a registry backed by the BuiltInLanguageParser fallback and no user registrations.

pub fn register( &mut self, language: impl Into<String>, parser: Arc<dyn LanguageParser>, ) -> &mut Self

Registers parser for language, shadowing any prior registration or built-in dispatch for the same (case-insensitive) key.

Returns &mut Self so registrations can be chained.

pub fn with_parser( self, language: impl Into<String>, parser: Arc<dyn LanguageParser>, ) -> Self

Builder-style variant of register that consumes and returns the registry.

pub fn parser_for(&self, language: &str) -> Option<&Arc<dyn LanguageParser>>

Returns the parser explicitly registered for language, if any.

Keys served by the built-in fallback report None; use parse to dispatch including the fallback.

pub fn is_registered(&self, language: &str) -> bool

Whether language has an explicit (non-fallback) registration.

pub fn len(&self) -> usize

The number of explicit registrations, excluding the built-in fallback.

pub fn is_empty(&self) -> bool

Whether the registry holds no explicit registrations.

An empty registry still parses every key through the built-in fallback.

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

Parses text for language, dispatching to a registered parser when one shadows the key and otherwise to the built-in fallback.

Trait Implementations

impl Clone for ParserRegistry

fn clone(&self) -> ParserRegistry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParserRegistry

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

Formats the value using the given formatter.

impl Default for ParserRegistry

fn default() -> Self

Returns the “default value” for a type.