Trait 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;

    // 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;
    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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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

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

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

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>

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