Type Alias neure::ctx::BytesCtx

pub type BytesCtx<'a> = RegexCtx<'a, [u8]>;

Aliased Type

struct BytesCtx<'a> { /* private fields */ }

Implementations

impl<'a, T> RegexCtx<'a, T>where T: ?Sized,

pub fn new(dat: &'a T) -> Self

pub fn dat(&self) -> &'a T

pub fn offset(&self) -> usize

pub fn with_dat(self, dat: &'a T) -> Self

pub fn with_offset(self, offset: usize) -> Self

pub fn reset_with(&mut self, dat: &'a T) -> &mut Self

pub fn reset(&mut self) -> &mut Self

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

pub fn with_policy<O>(self, before_policy: O) -> PolicyCtx<Self, O>where O: BPolicy<Self>,

impl<'a, T> RegexCtx<'a, T>where T: ?Sized,

pub fn ignore<R>(self, regex: R) -> PolicyCtx<Self, RePolicy<Self, R>>

impl<'a, T> RegexCtx<'a, T>where T: ?Sized, Self: Context<'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>, &'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<'a, T> Clone for RegexCtx<'a, T>where T: ?Sized,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Context<'a> for RegexCtx<'a, [u8]>

type Orig = [u8]

type Item = u8

type Iter<'b> = BytesIndices<'b, u8> 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<'a, T> Debug for RegexCtx<'a, T>where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<'a, T, R> Extract<'a, RegexCtx<'a, T>, R> for RegexCtx<'a, T>where T: ?Sized, Self: Context<'a>,

type Out<'b> = RegexCtx<'a, T>

type Error = Error

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

impl<'a, T> Match<RegexCtx<'a, T>> for RegexCtx<'a, T>where T: ?Sized, Self: Context<'a>,

fn try_mat_t<Pat: Regex<RegexCtx<'a, T>> + ?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, T, B> PolicyMatch<RegexCtx<'a, T>, B> for RegexCtx<'a, T>where T: ?Sized, Self: Context<'a>, B: BPolicy<RegexCtx<'a, T>>,

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

impl<'a, T> Copy for RegexCtx<'a, T>where T: ?Sized,