Trait neure::re::ctor::Ctor

pub trait Ctor<'a, C, M, O>where
    C: Context<'a>,{
    // Required method
    fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>
       where H: Handler<A, Out = M, Error = Error>,
             A: Extract<'a, C, Span, Out<'a> = A, Error = Error>;
}

Required Methods

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = M, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

Implementations on Foreign Types

impl<'a, C, M, O, I> Ctor<'a, C, M, O> for Option<I>where I: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = M, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, M, O, I> Ctor<'a, C, M, O> for Arc<I>where I: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = M, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, O> Ctor<'a, C, O, O> for Box<dyn Regex<C, Ret = Span>>where C: Context<'a> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = O, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, M, O, I> Ctor<'a, C, M, O> for Mutex<I>where I: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = M, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, const N: usize, C, O> Ctor<'a, C, O, O> for [u8; N]where C: Context<'a, Orig = [u8]> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = O, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, const N: usize, C, O> Ctor<'a, C, O, O> for &[u8; N]where C: Context<'a, Orig = [u8]> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = O, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, O> Ctor<'a, C, O, O> for Vec<u8>where C: Context<'a, Orig = [u8]> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = O, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, O> Ctor<'a, C, O, O> for &strwhere C: Context<'a, Orig = str> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = O, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, M, O, I> Ctor<'a, C, M, O> for Cell<I>where I: Ctor<'a, C, M, O> + Copy, C: Context<'a> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = M, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, O> Ctor<'a, C, O, O> for Stringwhere C: Context<'a, Orig = str> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = O, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, M, O, I> Ctor<'a, C, M, O> for Rc<I>where I: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = M, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, O> Ctor<'a, C, O, O> for &Vec<u8>where C: Context<'a, Orig = [u8]> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = O, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, O> Ctor<'a, C, O, O> for &Stringwhere C: Context<'a, Orig = str> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = O, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, M, O, I> Ctor<'a, C, M, O> for RefCell<I>where I: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = M, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

impl<'a, C, O> Ctor<'a, C, O, O> for &[u8]where C: Context<'a, Orig = [u8]> + Match<C>,

fn constrct<H, A>(&self, ctx: &mut C, handler: &mut H) -> Result<O, Error>where H: Handler<A, Out = O, Error = Error>, A: Extract<'a, C, Span, Out<'a> = A, Error = Error>,

Implementors

impl<'a, 'b, C, M, O> Ctor<'a, C, M, O> for DynamicCtor<'b, C, O>where C: Context<'a> + Match<C>,

impl<'a, 'b, C, O> Ctor<'a, C, O, O> for DynamicRegex<'b, C, Span>where C: Context<'a> + Match<C>,

impl<'a, 'b, C, O> Ctor<'a, C, O, O> for LitString<'b>where C: Context<'a, Orig = str> + Match<C>,

impl<'a, 'b, C, O, T> Ctor<'a, C, O, O> for LitSlice<'b, T>where T: PartialOrd + 'a, C: Context<'a, Orig = [T]> + Match<C>,

impl<'a, 'b, const N: usize, C, K, M, O, V> Ctor<'a, C, M, (O, V)> for PairSlice<'b, N, K, V>where V: Clone, K: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, 'b, const N: usize, C, T, M, O> Ctor<'a, C, M, O> for Slice<'b, N, T>where T: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, K, M, O, V> Ctor<'a, C, M, (O, V)> for PairVector<K, V>where V: Clone, K: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, L, I, R, M, O1, O2> Ctor<'a, C, M, (O1, Option<O2>)> for IfThen<C, L, I, R>where L: Ctor<'a, C, M, O1>, R: Ctor<'a, C, M, O2>, I: Regex<C, Ret = Span>, C: Context<'a> + Match<C>,

impl<'a, C, L, R, M, O1, O2> Ctor<'a, C, M, (O1, O2)> for Then<C, L, R>where L: Ctor<'a, C, M, O1>, R: Ctor<'a, C, M, O2>, C: Context<'a> + Match<C>,

impl<'a, C, L, R, M, O> Ctor<'a, C, M, O> for LongestTokenMatch<C, L, R>where L: Ctor<'a, C, M, O>, R: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, L, R, M, O> Ctor<'a, C, M, O> for Or<C, L, R>where L: Ctor<'a, C, M, O>, R: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, L, R, P, M, O> Ctor<'a, C, M, O> for Quote<C, P, L, R>where L: Regex<C, Ret = Span>, R: Regex<C, Ret = Span>, P: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, L, S, R, M, O1, O2> Ctor<'a, C, M, (O1, O2)> for SepOnce<C, L, S, R>where L: Ctor<'a, C, M, O1>, R: Ctor<'a, C, M, O2>, S: Regex<C, Ret = Span>, C: Context<'a> + Match<C>,

impl<'a, C, M, O, P> Ctor<'a, C, M, Option<O>> for OptionPat<C, P>where P: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, M, O, T> Ctor<'a, C, M, O> for BoxedCtor<C, T>where T: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, M, O, V, P, F> Ctor<'a, C, M, V> for Map<C, P, F, O>where P: Ctor<'a, C, M, O>, F: MapSingle<O, V>, C: Context<'a> + Match<C>,

impl<'a, C, O> Ctor<'a, C, O, O> for AnchorEndwhere C: Context<'a> + Match<C>,

impl<'a, C, O> Ctor<'a, C, O, O> for AnchorStartwhere C: Context<'a> + Match<C>,

impl<'a, C, O> Ctor<'a, C, O, O> for Consumewhere C: Context<'a> + Match<C>,

impl<'a, C, O> Ctor<'a, C, O, O> for ConsumeAllwhere C: Context<'a> + Match<C>,

impl<'a, C, O> Ctor<'a, C, O, O> for NullRegex<Span>where C: Context<'a> + Match<C>,

impl<'a, C, O, F> Ctor<'a, C, O, O> for Fwhere C: Context<'a> + Match<C>, F: Fn(&mut C) -> Result<Span, Error>,

impl<'a, C, O, P> Ctor<'a, C, O, O> for Pattern<C, P>where P: Regex<C, Ret = Span>, C: Context<'a> + Match<C>,

impl<'a, C, O, T> Ctor<'a, C, O, O> for RegexNot<T>where T: Regex<C, Ret = Span>, C: Context<'a> + Match<C>,

impl<'a, C, O, T> Ctor<'a, C, O, O> for BoxedRegex<C, T>where T: Regex<C, Ret = Span>, C: Context<'a> + Match<C>,

impl<'a, C, P, F, T, M, O1, O2> Ctor<'a, C, M, (O1, O2)> for DynamicCreateCtorThen<C, P, F>where P: Ctor<'a, C, M, O1>, T: Ctor<'a, C, M, O2>, C: Context<'a> + Match<C>, F: Fn(&O1) -> Result<T, Error>,

impl<'a, C, P, I, E, M, O> Ctor<'a, C, M, O> for IfRegex<C, P, I, E>where P: Ctor<'a, C, M, O>, E: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>, I: Fn(&C) -> Result<bool, Error>,

impl<'a, C, P, M, O> Ctor<'a, C, M, Vec<O, Global>> for Repeat<C, P>where P: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, P, M, O, V> Ctor<'a, C, M, V> for Collect<C, P, O, V>where V: FromIterator<O>, P: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, P, T, M, O> Ctor<'a, C, M, O> for Pad<C, P, T>where T: Regex<C, Ret = Span>, P: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, P, T, M, O> Ctor<'a, C, M, O> for Padded<C, P, T>where T: Regex<C, Ret = Span>, P: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, C, S, P, M, O> Ctor<'a, C, M, Vec<O, Global>> for Separate<C, P, S>where P: Ctor<'a, C, M, O>, S: Regex<C, Ret = Span>, C: Context<'a> + Match<C>,

impl<'a, C, S, P, M, O, V> Ctor<'a, C, M, V> for SepCollect<C, P, S, O, V>where V: FromIterator<O>, P: Ctor<'a, C, M, O>, S: Regex<C, Ret = Span>, C: Context<'a> + Match<C>,

impl<'a, C, T, M, O> Ctor<'a, C, M, O> for Vector<T>where T: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, L, R, C, O, I> Ctor<'a, C, O, O> for NeureThen<C, L, R, C::Item, I>where L: Neu<C::Item>, R: Neu<C::Item>, I: NeuCond<'a, C>, C: Context<'a> + Match<C> + 'a,

impl<'a, U, C, M, I> Ctor<'a, C, M, M> for NeureRepeatRange<C, U, I>where U: Neu<C::Item>, I: NeuCond<'a, C>, C: Context<'a> + Match<C> + 'a,

impl<'a, U, C, O, I> Ctor<'a, C, O, O> for NeureOne<C, U, C::Item, I>where C: Context<'a> + 'a + Match<C>, U: Neu<C::Item>, I: NeuCond<'a, C>,

impl<'a, U, C, O, I> Ctor<'a, C, O, O> for NeureOneMore<C, U, C::Item, I>where U: Neu<C::Item>, I: NeuCond<'a, C>, C: Context<'a> + Match<C> + 'a,

impl<'a, U, C, O, I> Ctor<'a, C, O, O> for NeureZeroMore<C, U, C::Item, I>where C: Context<'a> + 'a + Match<C>, U: Neu<C::Item>, I: NeuCond<'a, C>,

impl<'a, U, C, O, I> Ctor<'a, C, O, O> for NeureZeroOne<C, U, C::Item, I>where C: Context<'a> + 'a + Match<C>, U: Neu<C::Item>, I: NeuCond<'a, C>,

impl<'a, const M: usize, const N: usize, U, C, O, I> Ctor<'a, C, O, O> for NeureRepeat<M, N, C, U, I>where U: Neu<C::Item>, I: NeuCond<'a, C>, C: Context<'a> + Match<C> + 'a,

impl<'a, const N: usize, C, K, M, O, V> Ctor<'a, C, M, (O, V)> for PairArray<N, K, V>where V: Clone, K: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,

impl<'a, const N: usize, C, T, M, O> Ctor<'a, C, M, O> for Array<N, T>where T: Ctor<'a, C, M, O>, C: Context<'a> + Match<C>,