Trait Generator 

pub trait Generator<'a> {
    type Convertor: TagConvertor<'a>;
    type Output;
    type Err: LocatedError + Display + Debug + Into<Error<'a, Self::Err>>;

    // Required methods
    fn convertor(&mut self) -> &mut Self::Convertor;
    fn generate(
        &mut self,
        markup: Vec<Vec<ItemG<'a, Self>>>,
    ) -> Result<Self::Output, Self::Err>;
}

Generator generates final output to show tui markup in some backend.

How to add support for new backend

Some concepts:

• Markup text/Source: the text you write in tui markup language.
• Parser: parse markup text into a series of Item, which usually be called as AST.
• Tag Convertor: Convert raw tag string like green, bg:66ccff, mod:b into Tag.
• Generator: generator final output from Item<Tag>.

So the whole pipeline is:

Source --- Parser --> Item --- Tag Convertor --> Item<Tag> --- Generator --> Output --> Show it in some backend

The source, parser, Item, Tag, is already defined, so just write a Tag Convertor and a Generator, a new backend will be supported.

Generic implementation using flatten

Your tag convertor will parse color/modifiers string to some Color/Modifier type, and will support custom tag by a Style type, which can be converted from Color and Modifier too.

In this case, a Tag of this convertor can be convert to the Style type easily.

If this Style can be patched by other, then you can use the flatten help method to do almost all the convert staff from AST to your final result.

Read document of flatten to learn more, or just checkout a builtin implementation.

Required Associated Types

type Convertor: TagConvertor<'a>

Tag convertor type.

type Output

Output type.

type Err: LocatedError + Display + Debug + Into<Error<'a, Self::Err>>

Error type.

If the generator can’t fall, please use GeneratorInfallible.

Required Methods

fn convertor(&mut self) -> &mut Self::Convertor

Get the tag convertor.

fn generate( &mut self, markup: Vec<Vec<ItemG<'a, Self>>>, ) -> Result<Self::Output, Self::Err>

Generates final output from IR, which is output result of the Convertor.

Errors

When the generator can’t process the IR. This should be documented details.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'a, G: Generator<'a>> Generator<'a> for &mut G

type Convertor = <G as Generator<'a>>::Convertor

type Err = <G as Generator<'a>>::Err

type Output = <G as Generator<'a>>::Output

fn convertor(&mut self) -> &mut Self::Convertor

fn generate( &mut self, markup: Vec<Vec<ItemG<'a, G>>>, ) -> Result<Self::Output, Self::Err>

Implementors

impl<'a, P> Generator<'a> for ANSIStringsGenerator<P>

where P: CustomTagParser<Output = Style>,

Available on crate feature ansi only.

type Convertor = ANSITagConvertor<P>

type Err = GeneratorInfallible

type Output = StyledText<'a>

impl<'a, P> Generator<'a> for CrosstermCommandsGenerator<P>

where P: CustomTagParser<Output = ContentStyle>,

Available on crate feature crossterm only.

type Convertor = CrosstermTagConvertor<P>

type Err = GeneratorInfallible

type Output = Vec<Span<'a>>

impl<'a, P> Generator<'a> for RatatuiTextGenerator<P>

where P: CustomTagParser<Output = Style>,

Available on crate feature ratatui only.

type Convertor = RatatuiTagConvertor<P>

type Err = GeneratorInfallible

type Output = Text<'a>