Trait tui_markup::generator::Generator

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

    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.

Required Associated Types

type Convertor

Tag convertor type.

type Output

Output type.

type 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 ast, which is output result of the Convertor.

Implementations on Foreign Types

impl<'a, G: Generator<'a>> Generator<'a> for &mut G where
    G::Err: LocatedError + Display,
    G::Convertor: TagConvertor<'a>, 

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

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

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

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

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

Implementors

impl<'a, P> Generator<'a> for TuiTextGenerator<P> where
    P: CustomTagParser<Output = Style>, 

type Convertor = TuiTagParser<P>

type Output = Text<'a>

type Err = GeneratorInfallible