Struct neure::ctx::PolicyCtx

pub struct PolicyCtx<I, B> { /* private fields */ }

Implementations

impl<I, B> PolicyCtx<I, B>

pub fn new(inner: I, before_policy: B) -> Self

pub fn with_policy<O>(self, before_policy: O) -> PolicyCtx<I, O>

pub fn inner(&self) -> &I

pub fn inner_mut(&mut self) -> &mut I

pub fn set_inner(&mut self, dat: I) -> &mut Self

pub fn with_inner(self, dat: I) -> Self

pub fn reset_with(&mut self, dat: I) -> &mut Self

pub fn span_storer(&self, capacity: usize) -> SimpleStorer

impl<'a, I, B> PolicyCtx<I, B>where I: Context<'a>, Self: Context<'a>, B: BPolicy<I> + 'a,

pub fn ctor_with<H, A, P, M, O>( &mut self, pat: &P, handler: &mut H ) -> Result<O, Error>where P: Ctor<'a, Self, M, O>, H: Handler<A, Out = M, Error = Error>, A: Extract<'a, Self, Span, Out<'a> = A, Error = Error>,

pub fn map_with<H, A, P, O>(&mut self, pat: &P, handler: H) -> Result<O, Error>where P: Regex<Self, Ret = Span>, H: Handler<A, Out = O, Error = Error>, A: Extract<'a, Self, P::Ret, Out<'a> = A, Error = Error>,

pub fn ctor<P, O>(&mut self, pat: &P) -> Result<O, Error>where P: Ctor<'a, Self, &'a <Self as Context<'a>>::Orig, O>, &'a <Self as Context<'a>>::Orig: Extract<'a, Self, Span, Out<'a> = &'a <Self as Context<'a>>::Orig, Error = Error> + 'a,

pub fn map<P, O>( &mut self, pat: &P, mapper: impl MapSingle<&'a <Self as Context<'a>>::Orig, O> ) -> Result<O, Error>where P: Regex<Self, Ret = Span>, <Self as Context<'a>>::Orig: 'a, &'a <Self as Context<'a>>::Orig: Extract<'a, Self, P::Ret, Out<'a> = &'a <Self as Context<'a>>::Orig, Error = Error>,

pub fn ctor_span<P, O>(&mut self, pat: &P) -> Result<O, Error>where P: Ctor<'a, Self, Span, O>, Span: Extract<'a, Self, Span, Out<'a> = Span, Error = Error>,

pub fn map_span<P, O>( &mut self, pat: &P, mapper: impl MapSingle<Span, O> ) -> Result<O, Error>where P: Regex<Self, Ret = Span>, Span: Extract<'a, Self, P::Ret, Out<'a> = Span, Error = Error>,

Trait Implementations

impl<I, B> Clone for PolicyCtx<I, B>where I: Clone, B: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, I, B> Context<'a> for PolicyCtx<I, B>where B: Clone + 'a, I: Context<'a>,

type Orig = <I as Context<'a>>::Orig

type Item = <I as Context<'a>>::Item

type Iter<'b> = <I as Context<'a>>::Iter<'b> where Self: 'b

fn len(&self) -> usize

fn offset(&self) -> usize

fn set_offset(&mut self, offset: usize) -> &mut Self

fn inc(&mut self, offset: usize) -> &mut Self

fn dec(&mut self, offset: usize) -> &mut Self

fn orig_at(&self, offset: usize) -> Result<&'a Self::Orig, Error>

fn peek_at(&self, offset: usize) -> Result<Self::Iter<'a>, Error>

fn orig_sub(&self, offset: usize, len: usize) -> Result<&'a Self::Orig, Error>

fn clone_with(&self, orig: &'a Self::Orig) -> Self

fn is_empty(&self) -> bool

fn peek(&self) -> Result<Self::Iter<'a>, Error>

fn orig(&self) -> Result<&'a Self::Orig, Error>

impl<I: Debug, B: Debug> Debug for PolicyCtx<I, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, I, R, B> Extract<'a, PolicyCtx<I, B>, R> for PolicyCtx<I, B>where B: Clone, Self: Context<'a>, I: Context<'a> + Clone,

type Out<'b> = PolicyCtx<I, B>

type Error = Error

fn extract(ctx: &Self, _: &R) -> Result<Self::Out<'a>, Self::Error>

impl<'a, I, B> Match<PolicyCtx<I, B>> for PolicyCtx<I, B>where B: BPolicy<I>, I: Context<'a>, Self: Context<'a>,

fn try_mat_t<Pat: Regex<PolicyCtx<I, B>> + ?Sized>( &mut self, pat: &Pat ) -> Result<Pat::Ret, Error>

fn is_mat<Pat: Regex<C> + ?Sized>(&mut self, pat: &Pat) -> bool

fn try_mat<Pat: Regex<C, Ret = Span> + ?Sized>( &mut self, pat: &Pat ) -> Result<Pat::Ret, Error>

impl<'a, I, B> PolicyMatch<PolicyCtx<I, B>, B> for PolicyCtx<I, B>where B: BPolicy<I>, I: Context<'a>, Self: Context<'a>,

fn try_mat_policy<Pat>( &mut self, pat: &Pat, b_policy: &B ) -> Result<Pat::Ret, Error>where Pat: Regex<PolicyCtx<I, B>> + ?Sized,

impl<I, B> Copy for PolicyCtx<I, B>where B: Copy, I: Copy,