Struct unflow::grammar::designparser::DesignParser[−][src]

pub struct DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>,  {
    pub err_handler: H,
    // some fields omitted
}
Expand description

Parser for Design grammar

Fields

err_handler: H

Implementations

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn get_serialized_atn() -> &'static str[src]

pub fn set_error_strategy(&mut self, strategy: H)[src]

pub fn with_strategy(input: I, strategy: H) -> Self[src]

impl<'input, I> DesignParser<'input, I, Box<dyn ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>> + 'input>> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>, [src]

pub fn with_dyn_strategy(input: I) -> Self[src]

impl<'input, I> DesignParser<'input, I, DefaultErrorStrategy<'input, DesignParserContextType>> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>, [src]

pub fn new(input: I) -> Self[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn start(&mut self) -> Result<Rc<StartContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn comment(&mut self) -> Result<Rc<CommentContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn config_decl(
    &mut self
) -> Result<Rc<Config_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn config_key(
    &mut self
) -> Result<Rc<Config_keyContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn config_value(
    &mut self
) -> Result<Rc<Config_valueContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn unit(&mut self) -> Result<Rc<UnitContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn declarations(
    &mut self
) -> Result<Rc<DeclarationsContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn flow_decl(
    &mut self
) -> Result<Rc<Flow_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn interaction_decl(
    &mut self
) -> Result<Rc<Interaction_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn see_decl(&mut self) -> Result<Rc<See_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn do_decl(&mut self) -> Result<Rc<Do_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn react_decl(
    &mut self
) -> Result<Rc<React_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn animate_decl(
    &mut self
) -> Result<Rc<Animate_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn react_action(
    &mut self
) -> Result<Rc<React_actionContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn goto_action(
    &mut self
) -> Result<Rc<Goto_actionContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn show_action(
    &mut self
) -> Result<Rc<Show_actionContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn action_name(
    &mut self
) -> Result<Rc<Action_nameContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn component_value(
    &mut self
) -> Result<Rc<Component_valueContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn component_name(
    &mut self
) -> Result<Rc<Component_nameContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn scene_name(
    &mut self
) -> Result<Rc<Scene_nameContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn animate_name(
    &mut self
) -> Result<Rc<Animate_nameContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn page_decl(
    &mut self
) -> Result<Rc<Page_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn component_decl(
    &mut self
) -> Result<Rc<Component_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn component_body_decl(
    &mut self
) -> Result<Rc<Component_body_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn layout_decl(
    &mut self
) -> Result<Rc<Layout_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn flex_child(
    &mut self
) -> Result<Rc<Flex_childContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn component_use_decl(
    &mut self
) -> Result<Rc<Component_use_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn component_layout_value(
    &mut self
) -> Result<Rc<Component_layout_valueContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn style_decl(
    &mut self
) -> Result<Rc<Style_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn style_name(
    &mut self
) -> Result<Rc<Style_nameContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn style_body(
    &mut self
) -> Result<Rc<Style_bodyContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn library_decl(
    &mut self
) -> Result<Rc<Library_declContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn library_exp(
    &mut self
) -> Result<Rc<Library_expContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn key_value(
    &mut self
) -> Result<Rc<Key_valueContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn preset_key(
    &mut self
) -> Result<Rc<Preset_keyContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn preset_value(
    &mut self
) -> Result<Rc<Preset_valueContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn preset_array(
    &mut self
) -> Result<Rc<Preset_arrayContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn preset_call(
    &mut self
) -> Result<Rc<Preset_callContextAll<'input>>, ANTLRError>[src]

impl<'input, I, H> DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

pub fn library_name(
    &mut self
) -> Result<Rc<Library_nameContextAll<'input>>, ANTLRError>[src]

Methods from Deref<Target = BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>

pub fn match_token(
    &mut self,
    ttype: isize,
    err_handler: &mut impl ErrorStrategy<'input, BaseParser<'input, Ext, I, Ctx, T>>
) -> Result<<<I as TokenStream<'input>>::TF as TokenFactory<'input>>::Tok, ANTLRError>[src]

pub fn match_wildcard(
    &mut self,
    err_handler: &mut impl ErrorStrategy<'input, BaseParser<'input, Ext, I, Ctx, T>>
) -> Result<<<I as TokenStream<'input>>::TF as TokenFactory<'input>>::Tok, ANTLRError>[src]

pub fn add_parse_listener<L>(
    &mut self,
    listener: Box<L, Global>
) -> ListenerId<L> where
    Box<L, Global>: CoerceUnsized<Box<T, Global>>, [src]

Adds parse listener for this parser returns listener_id that can be used later to get listener back

Embedded listener currently must outlive 'input. If you need to have arbitrary listener use ParseTreeWalker.

Example for listener usage:

todo

pub fn remove_parse_listener<L>(
    &mut self,
    listener_id: ListenerId<L>
) -> Box<L, Global>ⓘ

Notable traits for Box<R, Global>

impl<R> Read for Box<R, Global> where
    R: Read + ?Sized, impl<W> Write for Box<W, Global> where
    W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
    A: Allocator + 'static,
    F: Future + Unpin + ?Sized,  type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
    I: Iterator + ?Sized,
    A: Allocator,  type Item = <I as Iterator>::Item;
 where
    Box<L, Global>: CoerceUnsized<Box<T, Global>>, [src]

Removes parse listener with corresponding listener_id, casts it back to user type and returns it to the caller. listener_id is returned when listener is added via add_parse_listener

pub fn remove_parse_listeners(&mut self)[src]

Removes all added parse listeners without returning them

pub fn trigger_enter_rule_event(&mut self)[src]

pub fn trigger_exit_rule_event(&mut self)[src]

pub fn enter_rule(
    &mut self,
    localctx: Rc<<Ctx as ParserNodeType<'input>>::Type>,
    state: isize,
    _rule_index: usize
)[src]

pub fn exit_rule(&mut self)[src]

pub fn enter_outer_alt(
    &mut self,
    new_ctx: Option<Rc<<Ctx as ParserNodeType<'input>>::Type>>,
    alt_num: isize
)[src]

pub fn enter_recursion_rule(
    &mut self,
    localctx: Rc<<Ctx as ParserNodeType<'input>>::Type>,
    state: isize,
    _rule_index: usize,
    precedence: isize
)[src]

pub fn push_new_recursion_context(
    &mut self,
    localctx: Rc<<Ctx as ParserNodeType<'input>>::Type>,
    state: isize,
    _rule_index: usize
)[src]

pub fn unroll_recursion_context(
    &mut self,
    parent_ctx: Option<Rc<<Ctx as ParserNodeType<'input>>::Type>>
)[src]

pub fn dump_dfa(&self)[src]

Text representation of generated DFA for debugging purposes

Trait Implementations

impl<'input, I, H> Deref for DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

type Target = BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target[src]

Dereferences the value.

impl<'input, I, H> DerefMut for DesignParser<'input, I, H> where
    I: TokenStream<'input, TF = LocalTokenFactory<'input>> + TidAble<'input>,
    H: ErrorStrategy<'input, BaseParser<'input, DesignParserExt, I, DesignParserContextType, dyn DesignListener<'input> + 'input>>, [src]

fn deref_mut(&mut self) -> &mut Self::Target[src]

Mutably dereferences the value.

Auto Trait Implementations

impl<'input, I, H> !RefUnwindSafe for DesignParser<'input, I, H>

impl<'input, I, H> !Send for DesignParser<'input, I, H>

impl<'input, I, H> !Sync for DesignParser<'input, I, H>

impl<'input, I, H> Unpin for DesignParser<'input, I, H> where
    H: Unpin,
    I: Unpin, 

impl<'input, I, H> !UnwindSafe for DesignParser<'input, I, H>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T, U> Into<U> for T where
    U: From<T>, [src]

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> NodeText for T[src]

pub default fn get_node_text(&self, _rule_names: &[&str]) -> String[src]

Returns text representation of current node type, rule name for context nodes and token text for terminal nodes Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.