Trait antlr_rust::token_factory::TokenFactory

pub trait TokenFactory<'a>: TidAble<'a> + Sized {
    type Inner: Token<Data = Self::Data> + ?Sized + 'a;
    type Tok: Borrow<Self::Inner> + Clone + 'a + Debug;
    type Data: InputData + ?Sized;
    type From;

    fn create<T>(
        &'a self,
        source: Option<&mut T>,
        ttype: isize,
        text: Option<<Self::Data as ToOwned>::Owned>,
        channel: isize,
        start: isize,
        stop: isize,
        line: isize,
        column: isize
    ) -> Self::Tok
    where
        T: CharStream<Self::From> + ?Sized;
    fn create_invalid() -> Self::Tok;
    fn get_data(from: Self::From) -> Cow<'a, Self::Data>;
}

Trait for creating tokens.

Required Associated Types

type Inner: Token<Data = Self::Data> + ?Sized + 'a

Type of tokens emitted by this factory.

type Tok: Borrow<Self::Inner> + Clone + 'a + Debug

Ownership of the emitted tokens

type Data: InputData + ?Sized

Type of the underlying storage

type From

Type of the CharStream that factory can produce tokens from

Required Methods

fn create<T>(
    &'a self,
    source: Option<&mut T>,
    ttype: isize,
    text: Option<<Self::Data as ToOwned>::Owned>,
    channel: isize,
    start: isize,
    stop: isize,
    line: isize,
    column: isize
) -> Self::Tok where
    T: CharStream<Self::From> + ?Sized, 

Creates token either from sourse or from pure data in text Either source or text are not None

fn create_invalid() -> Self::Tok

Creates invalid token Invalid tokens must have TOKEN_INVALID_TYPE token type.

fn get_data(from: Self::From) -> Cow<'a, Self::Data>

Creates Self::Data representation for from for lexer to work with when it does not need to create full token

Implementors

impl<'a> TokenFactory<'a> for CommonTokenFactory

type Inner = GenericToken<Cow<'a, str>>

type Tok = Box<<CommonTokenFactory as TokenFactory<'a>>::Inner, Global>

type Data = str

type From = Cow<'a, str>

impl<'a> TokenFactory<'a> for OwningTokenFactory

type Inner = GenericToken<String>

type Tok = Box<<OwningTokenFactory as TokenFactory<'a>>::Inner, Global>

type Data = str

type From = String

impl<'input, TF, Tok> TokenFactory<'input> for ArenaFactory<'input, TF, Tok> where
    TF: TokenFactory<'input, Tok = Box<Tok>, Inner = Tok>,
    Tok: Token<Data = TF::Data> + Clone + TidAble<'input>,
    for<'a> &'a Tok: Default, 

type Inner = Tok

type Tok = &'input Tok

type Data = <TF as TokenFactory<'input>>::Data

type From = <TF as TokenFactory<'input>>::From