1use crate::error::{ContextError, ErrMode, ErrorKind, FromExternalError, ParseError};
2use crate::lib::std::borrow::Borrow;
3use crate::lib::std::ops::Range;
4use crate::stream::{Location, Stream};
5use crate::stream::{Offset, StreamIsPartial};
6use crate::trace::trace;
7use crate::trace::trace_result;
8use crate::*;
9
10/// Implementation of [`Parser::by_ref`][Parser::by_ref]
11#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
12pub struct ByRef<'p, P> {
13 p: &'p mut P,
14}
15
16impl<'p, P> ByRef<'p, P> {
17 pub(crate) fn new(p: &'p mut P) -> Self {
18 Self { p }
19 }
20}
21
22impl<'p, I, O, E, P: Parser<I, O, E>> Parser<I, O, E> for ByRef<'p, P> {
23 fn parse_next(&mut self, i: I) -> IResult<I, O, E> {
24 self.p.parse_next(input:i)
25 }
26}
27
28/// Implementation of [`Parser::map`]
29#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
30pub struct Map<F, G, I, O, O2, E>
31where
32 F: Parser<I, O, E>,
33 G: Fn(O) -> O2,
34{
35 parser: F,
36 map: G,
37 i: core::marker::PhantomData<I>,
38 o: core::marker::PhantomData<O>,
39 o2: core::marker::PhantomData<O2>,
40 e: core::marker::PhantomData<E>,
41}
42
43impl<F, G, I, O, O2, E> Map<F, G, I, O, O2, E>
44where
45 F: Parser<I, O, E>,
46 G: Fn(O) -> O2,
47{
48 pub(crate) fn new(parser: F, map: G) -> Self {
49 Self {
50 parser,
51 map,
52 i: Default::default(),
53 o: Default::default(),
54 o2: Default::default(),
55 e: Default::default(),
56 }
57 }
58}
59
60impl<F, G, I, O, O2, E> Parser<I, O2, E> for Map<F, G, I, O, O2, E>
61where
62 F: Parser<I, O, E>,
63 G: Fn(O) -> O2,
64{
65 fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
66 match self.parser.parse_next(input:i) {
67 Err(e: ErrMode) => Err(e),
68 Ok((i: I, o: O)) => Ok((i, (self.map)(o))),
69 }
70 }
71}
72
73#[deprecated(since = "0.4.2", note = "Replaced with `TryMap`")]
74pub use TryMap as MapRes;
75
76/// Implementation of [`Parser::try_map`]
77#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
78pub struct TryMap<F, G, I, O, O2, E, E2>
79where
80 F: Parser<I, O, E>,
81 G: FnMut(O) -> Result<O2, E2>,
82 I: Clone,
83 E: FromExternalError<I, E2>,
84{
85 parser: F,
86 map: G,
87 i: core::marker::PhantomData<I>,
88 o: core::marker::PhantomData<O>,
89 o2: core::marker::PhantomData<O2>,
90 e: core::marker::PhantomData<E>,
91 e2: core::marker::PhantomData<E2>,
92}
93
94impl<F, G, I, O, O2, E, E2> TryMap<F, G, I, O, O2, E, E2>
95where
96 F: Parser<I, O, E>,
97 G: FnMut(O) -> Result<O2, E2>,
98 I: Clone,
99 E: FromExternalError<I, E2>,
100{
101 pub(crate) fn new(parser: F, map: G) -> Self {
102 Self {
103 parser,
104 map,
105 i: Default::default(),
106 o: Default::default(),
107 o2: Default::default(),
108 e: Default::default(),
109 e2: Default::default(),
110 }
111 }
112}
113
114impl<F, G, I, O, O2, E, E2> Parser<I, O2, E> for TryMap<F, G, I, O, O2, E, E2>
115where
116 F: Parser<I, O, E>,
117 G: FnMut(O) -> Result<O2, E2>,
118 I: Clone,
119 E: FromExternalError<I, E2>,
120{
121 fn parse_next(&mut self, input: I) -> IResult<I, O2, E> {
122 let i: I = input.clone();
123 let (input: I, o: O) = self.parser.parse_next(input)?;
124 let res: Result<(I, O2), ErrMode> = match (self.map)(o) {
125 Ok(o2: O2) => Ok((input, o2)),
126 Err(e: E2) => Err(ErrMode::from_external_error(input:i, kind:ErrorKind::Verify, e)),
127 };
128 trace_result(name:"verify", &res);
129 res
130 }
131}
132
133/// Implementation of [`Parser::verify_map`]
134#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
135pub struct VerifyMap<F, G, I, O, O2, E>
136where
137 F: Parser<I, O, E>,
138 G: FnMut(O) -> Option<O2>,
139 I: Clone,
140 E: ParseError<I>,
141{
142 parser: F,
143 map: G,
144 i: core::marker::PhantomData<I>,
145 o: core::marker::PhantomData<O>,
146 o2: core::marker::PhantomData<O2>,
147 e: core::marker::PhantomData<E>,
148}
149
150impl<F, G, I, O, O2, E> VerifyMap<F, G, I, O, O2, E>
151where
152 F: Parser<I, O, E>,
153 G: FnMut(O) -> Option<O2>,
154 I: Clone,
155 E: ParseError<I>,
156{
157 pub(crate) fn new(parser: F, map: G) -> Self {
158 Self {
159 parser,
160 map,
161 i: Default::default(),
162 o: Default::default(),
163 o2: Default::default(),
164 e: Default::default(),
165 }
166 }
167}
168
169impl<F, G, I, O, O2, E> Parser<I, O2, E> for VerifyMap<F, G, I, O, O2, E>
170where
171 F: Parser<I, O, E>,
172 G: FnMut(O) -> Option<O2>,
173 I: Clone,
174 E: ParseError<I>,
175{
176 fn parse_next(&mut self, input: I) -> IResult<I, O2, E> {
177 let i: I = input.clone();
178 let (input: I, o: O) = self.parser.parse_next(input)?;
179 let res: Result<(I, O2), ErrMode> = match (self.map)(o) {
180 Some(o2: O2) => Ok((input, o2)),
181 None => Err(ErrMode::from_error_kind(input:i, kind:ErrorKind::Verify)),
182 };
183 trace_result(name:"verify", &res);
184 res
185 }
186}
187
188/// Implementation of [`Parser::and_then`]
189#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
190pub struct AndThen<F, G, I, O, O2, E>
191where
192 F: Parser<I, O, E>,
193 G: Parser<O, O2, E>,
194 O: StreamIsPartial,
195{
196 outer: F,
197 inner: G,
198 i: core::marker::PhantomData<I>,
199 o: core::marker::PhantomData<O>,
200 o2: core::marker::PhantomData<O2>,
201 e: core::marker::PhantomData<E>,
202}
203
204impl<F, G, I, O, O2, E> AndThen<F, G, I, O, O2, E>
205where
206 F: Parser<I, O, E>,
207 G: Parser<O, O2, E>,
208 O: StreamIsPartial,
209{
210 pub(crate) fn new(outer: F, inner: G) -> Self {
211 Self {
212 outer,
213 inner,
214 i: Default::default(),
215 o: Default::default(),
216 o2: Default::default(),
217 e: Default::default(),
218 }
219 }
220}
221
222impl<F, G, I, O, O2, E> Parser<I, O2, E> for AndThen<F, G, I, O, O2, E>
223where
224 F: Parser<I, O, E>,
225 G: Parser<O, O2, E>,
226 O: StreamIsPartial,
227{
228 fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
229 let (i: I, mut o: O) = self.outer.parse_next(input:i)?;
230 let _ = o.complete();
231 let (_, o2: O2) = self.inner.parse_next(input:o)?;
232 Ok((i, o2))
233 }
234}
235
236/// Implementation of [`Parser::parse_to`]
237#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
238pub struct ParseTo<P, I, O, O2, E>
239where
240 P: Parser<I, O, E>,
241 I: Stream,
242 O: crate::stream::ParseSlice<O2>,
243 E: ParseError<I>,
244{
245 p: P,
246 i: core::marker::PhantomData<I>,
247 o: core::marker::PhantomData<O>,
248 o2: core::marker::PhantomData<O2>,
249 e: core::marker::PhantomData<E>,
250}
251
252impl<P, I, O, O2, E> ParseTo<P, I, O, O2, E>
253where
254 P: Parser<I, O, E>,
255 I: Stream,
256 O: crate::stream::ParseSlice<O2>,
257 E: ParseError<I>,
258{
259 pub(crate) fn new(p: P) -> Self {
260 Self {
261 p,
262 i: Default::default(),
263 o: Default::default(),
264 o2: Default::default(),
265 e: Default::default(),
266 }
267 }
268}
269
270impl<P, I, O, O2, E> Parser<I, O2, E> for ParseTo<P, I, O, O2, E>
271where
272 P: Parser<I, O, E>,
273 I: Stream,
274 O: crate::stream::ParseSlice<O2>,
275 E: ParseError<I>,
276{
277 fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
278 let input: I = i.clone();
279 let (i: I, o: O) = self.p.parse_next(input:i)?;
280
281 let res: Result> = o
282 .parse_slice()
283 .ok_or_else(|| ErrMode::from_error_kind(input, kind:ErrorKind::Verify));
284 trace_result(name:"verify", &res);
285 Ok((i, res?))
286 }
287}
288
289/// Implementation of [`Parser::flat_map`]
290#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
291pub struct FlatMap<F, G, H, I, O, O2, E>
292where
293 F: Parser<I, O, E>,
294 G: FnMut(O) -> H,
295 H: Parser<I, O2, E>,
296{
297 f: F,
298 g: G,
299 h: core::marker::PhantomData<H>,
300 i: core::marker::PhantomData<I>,
301 o: core::marker::PhantomData<O>,
302 o2: core::marker::PhantomData<O2>,
303 e: core::marker::PhantomData<E>,
304}
305
306impl<F, G, H, I, O, O2, E> FlatMap<F, G, H, I, O, O2, E>
307where
308 F: Parser<I, O, E>,
309 G: FnMut(O) -> H,
310 H: Parser<I, O2, E>,
311{
312 pub(crate) fn new(f: F, g: G) -> Self {
313 Self {
314 f,
315 g,
316 h: Default::default(),
317 i: Default::default(),
318 o: Default::default(),
319 o2: Default::default(),
320 e: Default::default(),
321 }
322 }
323}
324
325impl<F, G, H, I, O, O2, E> Parser<I, O2, E> for FlatMap<F, G, H, I, O, O2, E>
326where
327 F: Parser<I, O, E>,
328 G: FnMut(O) -> H,
329 H: Parser<I, O2, E>,
330{
331 fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
332 let (i: I, o: O) = self.f.parse_next(input:i)?;
333 (self.g)(o).parse_next(input:i)
334 }
335}
336
337/// Implementation of [`Parser::complete_err`]
338#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
339pub struct CompleteErr<F> {
340 f: F,
341}
342
343impl<F> CompleteErr<F> {
344 pub(crate) fn new(f: F) -> Self {
345 Self { f }
346 }
347}
348
349impl<F, I, O, E> Parser<I, O, E> for CompleteErr<F>
350where
351 I: Stream,
352 F: Parser<I, O, E>,
353 E: ParseError<I>,
354{
355 fn parse_next(&mut self, input: I) -> IResult<I, O, E> {
356 traceimpl Parser(name:"complete_err", |input: I| {
357 let i: I = input.clone();
358 match (self.f).parse_next(input) {
359 Err(ErrMode::Incomplete(_)) => {
360 Err(ErrMode::from_error_kind(input:i, kind:ErrorKind::Complete))
361 }
362 rest: Result<(I, O), ErrMode> => rest,
363 }
364 })
365 .parse_next(input)
366 }
367}
368
369/// Implementation of [`Parser::verify`]
370#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
371pub struct Verify<F, G, I, O, O2, E>
372where
373 F: Parser<I, O, E>,
374 G: Fn(&O2) -> bool,
375 I: Clone,
376 O: Borrow<O2>,
377 O2: ?Sized,
378 E: ParseError<I>,
379{
380 parser: F,
381 filter: G,
382 i: core::marker::PhantomData<I>,
383 o: core::marker::PhantomData<O>,
384 o2: core::marker::PhantomData<O2>,
385 e: core::marker::PhantomData<E>,
386}
387
388impl<F, G, I, O, O2, E> Verify<F, G, I, O, O2, E>
389where
390 F: Parser<I, O, E>,
391 G: Fn(&O2) -> bool,
392 I: Clone,
393 O: Borrow<O2>,
394 O2: ?Sized,
395 E: ParseError<I>,
396{
397 pub(crate) fn new(parser: F, filter: G) -> Self {
398 Self {
399 parser,
400 filter,
401 i: Default::default(),
402 o: Default::default(),
403 o2: Default::default(),
404 e: Default::default(),
405 }
406 }
407}
408
409impl<F, G, I, O, O2, E> Parser<I, O, E> for Verify<F, G, I, O, O2, E>
410where
411 F: Parser<I, O, E>,
412 G: Fn(&O2) -> bool,
413 I: Clone,
414 O: Borrow<O2>,
415 O2: ?Sized,
416 E: ParseError<I>,
417{
418 fn parse_next(&mut self, input: I) -> IResult<I, O, E> {
419 let i: I = input.clone();
420 let (input: I, o: O) = self.parser.parse_next(input)?;
421
422 let res: Result<(I, O), ErrMode> = if (self.filter)(o.borrow()) {
423 Ok((input, o))
424 } else {
425 Err(ErrMode::from_error_kind(input:i, kind:ErrorKind::Verify))
426 };
427 trace_result(name:"verify", &res);
428 res
429 }
430}
431
432/// Implementation of [`Parser::value`]
433#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
434pub struct Value<F, I, O, O2, E>
435where
436 F: Parser<I, O, E>,
437 O2: Clone,
438{
439 parser: F,
440 val: O2,
441 i: core::marker::PhantomData<I>,
442 o: core::marker::PhantomData<O>,
443 e: core::marker::PhantomData<E>,
444}
445
446impl<F, I, O, O2, E> Value<F, I, O, O2, E>
447where
448 F: Parser<I, O, E>,
449 O2: Clone,
450{
451 pub(crate) fn new(parser: F, val: O2) -> Self {
452 Self {
453 parser,
454 val,
455 i: Default::default(),
456 o: Default::default(),
457 e: Default::default(),
458 }
459 }
460}
461
462impl<F, I, O, O2, E> Parser<I, O2, E> for Value<F, I, O, O2, E>
463where
464 F: Parser<I, O, E>,
465 O2: Clone,
466{
467 fn parse_next(&mut self, input: I) -> IResult<I, O2, E> {
468 (self.parser)
469 .parse_next(input)
470 .map(|(i: I, _)| (i, self.val.clone()))
471 }
472}
473
474/// Implementation of [`Parser::void`]
475#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
476pub struct Void<F, I, O, E>
477where
478 F: Parser<I, O, E>,
479{
480 parser: F,
481 i: core::marker::PhantomData<I>,
482 o: core::marker::PhantomData<O>,
483 e: core::marker::PhantomData<E>,
484}
485
486impl<F, I, O, E> Void<F, I, O, E>
487where
488 F: Parser<I, O, E>,
489{
490 pub(crate) fn new(parser: F) -> Self {
491 Self {
492 parser,
493 i: Default::default(),
494 o: Default::default(),
495 e: Default::default(),
496 }
497 }
498}
499
500impl<F, I, O, E> Parser<I, (), E> for Void<F, I, O, E>
501where
502 F: Parser<I, O, E>,
503{
504 fn parse_next(&mut self, input: I) -> IResult<I, (), E> {
505 (self.parser).parse_next(input).map(|(i: I, _)| (i, ()))
506 }
507}
508
509/// Implementation of [`Parser::recognize`]
510#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
511pub struct Recognize<F, I, O, E>
512where
513 F: Parser<I, O, E>,
514 I: Stream + Offset,
515{
516 parser: F,
517 i: core::marker::PhantomData<I>,
518 o: core::marker::PhantomData<O>,
519 e: core::marker::PhantomData<E>,
520}
521
522impl<F, I, O, E> Recognize<F, I, O, E>
523where
524 F: Parser<I, O, E>,
525 I: Stream + Offset,
526{
527 pub(crate) fn new(parser: F) -> Self {
528 Self {
529 parser,
530 i: Default::default(),
531 o: Default::default(),
532 e: Default::default(),
533 }
534 }
535}
536
537impl<I, O, E, F> Parser<I, <I as Stream>::Slice, E> for Recognize<F, I, O, E>
538where
539 F: Parser<I, O, E>,
540 I: Stream + Offset,
541{
542 fn parse_next(&mut self, input: I) -> IResult<I, <I as Stream>::Slice, E> {
543 let i: I = input.clone();
544 match (self.parser).parse_next(input:i) {
545 Ok((i: I, _)) => {
546 let offset: usize = input.offset_to(&i);
547 Ok(input.next_slice(offset))
548 }
549 Err(e: ErrMode) => Err(e),
550 }
551 }
552}
553
554/// Implementation of [`Parser::with_recognized`]
555#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
556pub struct WithRecognized<F, I, O, E>
557where
558 F: Parser<I, O, E>,
559 I: Stream + Offset,
560{
561 parser: F,
562 i: core::marker::PhantomData<I>,
563 o: core::marker::PhantomData<O>,
564 e: core::marker::PhantomData<E>,
565}
566
567impl<F, I, O, E> WithRecognized<F, I, O, E>
568where
569 F: Parser<I, O, E>,
570 I: Stream + Offset,
571{
572 pub(crate) fn new(parser: F) -> Self {
573 Self {
574 parser,
575 i: Default::default(),
576 o: Default::default(),
577 e: Default::default(),
578 }
579 }
580}
581
582impl<F, I, O, E> Parser<I, (O, <I as Stream>::Slice), E> for WithRecognized<F, I, O, E>
583where
584 F: Parser<I, O, E>,
585 I: Stream + Offset,
586{
587 fn parse_next(&mut self, input: I) -> IResult<I, (O, <I as Stream>::Slice), E> {
588 let i: I = input.clone();
589 match (self.parser).parse_next(input:i) {
590 Ok((remaining: I, result: O)) => {
591 let offset: usize = input.offset_to(&remaining);
592 let (remaining: I, recognized: ::Slice) = input.next_slice(offset);
593 Ok((remaining, (result, recognized)))
594 }
595 Err(e: ErrMode) => Err(e),
596 }
597 }
598}
599
600/// Implementation of [`Parser::span`]
601#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
602pub struct Span<F, I, O, E>
603where
604 F: Parser<I, O, E>,
605 I: Clone + Location,
606{
607 parser: F,
608 i: core::marker::PhantomData<I>,
609 o: core::marker::PhantomData<O>,
610 e: core::marker::PhantomData<E>,
611}
612
613impl<F, I, O, E> Span<F, I, O, E>
614where
615 F: Parser<I, O, E>,
616 I: Clone + Location,
617{
618 pub(crate) fn new(parser: F) -> Self {
619 Self {
620 parser,
621 i: Default::default(),
622 o: Default::default(),
623 e: Default::default(),
624 }
625 }
626}
627
628impl<I, O, E, F> Parser<I, Range<usize>, E> for Span<F, I, O, E>
629where
630 F: Parser<I, O, E>,
631 I: Clone + Location,
632{
633 fn parse_next(&mut self, input: I) -> IResult<I, Range<usize>, E> {
634 let start: usize = input.location();
635 self.parser.parse_next(input).map(op:move |(remaining: I, _)| {
636 let end: usize = remaining.location();
637 (remaining, (start..end))
638 })
639 }
640}
641
642/// Implementation of [`Parser::with_span`]
643#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
644pub struct WithSpan<F, I, O, E>
645where
646 F: Parser<I, O, E>,
647 I: Clone + Location,
648{
649 parser: F,
650 i: core::marker::PhantomData<I>,
651 o: core::marker::PhantomData<O>,
652 e: core::marker::PhantomData<E>,
653}
654
655impl<F, I, O, E> WithSpan<F, I, O, E>
656where
657 F: Parser<I, O, E>,
658 I: Clone + Location,
659{
660 pub(crate) fn new(parser: F) -> Self {
661 Self {
662 parser,
663 i: Default::default(),
664 o: Default::default(),
665 e: Default::default(),
666 }
667 }
668}
669
670impl<F, I, O, E> Parser<I, (O, Range<usize>), E> for WithSpan<F, I, O, E>
671where
672 F: Parser<I, O, E>,
673 I: Clone + Location,
674{
675 fn parse_next(&mut self, input: I) -> IResult<I, (O, Range<usize>), E> {
676 let start: usize = input.location();
677 self.parser
678 .parse_next(input)
679 .map(op:move |(remaining: I, output: O)| {
680 let end: usize = remaining.location();
681 (remaining, (output, (start..end)))
682 })
683 }
684}
685
686/// Implementation of [`Parser::output_into`]
687#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
688pub struct OutputInto<F, I, O, O2, E>
689where
690 F: Parser<I, O, E>,
691 O: Into<O2>,
692{
693 parser: F,
694 i: core::marker::PhantomData<I>,
695 o: core::marker::PhantomData<O>,
696 o2: core::marker::PhantomData<O2>,
697 e: core::marker::PhantomData<E>,
698}
699
700impl<F, I, O, O2, E> OutputInto<F, I, O, O2, E>
701where
702 F: Parser<I, O, E>,
703 O: Into<O2>,
704{
705 pub(crate) fn new(parser: F) -> Self {
706 Self {
707 parser,
708 i: Default::default(),
709 o: Default::default(),
710 o2: Default::default(),
711 e: Default::default(),
712 }
713 }
714}
715
716impl<F, I, O, O2, E> Parser<I, O2, E> for OutputInto<F, I, O, O2, E>
717where
718 F: Parser<I, O, E>,
719 O: Into<O2>,
720{
721 fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
722 match self.parser.parse_next(input:i) {
723 Ok((i: I, o: O)) => Ok((i, o.into())),
724 Err(err: ErrMode) => Err(err),
725 }
726 }
727}
728
729/// Implementation of [`Parser::err_into`]
730#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
731pub struct ErrInto<F, I, O, E, E2>
732where
733 F: Parser<I, O, E>,
734 E: Into<E2>,
735{
736 parser: F,
737 i: core::marker::PhantomData<I>,
738 o: core::marker::PhantomData<O>,
739 e: core::marker::PhantomData<E>,
740 e2: core::marker::PhantomData<E2>,
741}
742
743impl<F, I, O, E, E2> ErrInto<F, I, O, E, E2>
744where
745 F: Parser<I, O, E>,
746 E: Into<E2>,
747{
748 pub(crate) fn new(parser: F) -> Self {
749 Self {
750 parser,
751 i: Default::default(),
752 o: Default::default(),
753 e: Default::default(),
754 e2: Default::default(),
755 }
756 }
757}
758
759impl<F, I, O, E, E2> Parser<I, O, E2> for ErrInto<F, I, O, E, E2>
760where
761 F: Parser<I, O, E>,
762 E: Into<E2>,
763{
764 fn parse_next(&mut self, i: I) -> IResult<I, O, E2> {
765 match self.parser.parse_next(input:i) {
766 Ok(ok: (I, O)) => Ok(ok),
767 Err(ErrMode::Backtrack(e: E)) => Err(ErrMode::Backtrack(e.into())),
768 Err(ErrMode::Cut(e: E)) => Err(ErrMode::Cut(e.into())),
769 Err(ErrMode::Incomplete(e: Needed)) => Err(ErrMode::Incomplete(e)),
770 }
771 }
772}
773
774/// Implementation of [`Parser::context`]
775#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
776pub struct Context<F, I, O, E, C>
777where
778 F: Parser<I, O, E>,
779 I: Stream,
780 E: ContextError<I, C>,
781 C: Clone + crate::lib::std::fmt::Debug,
782{
783 parser: F,
784 context: C,
785 i: core::marker::PhantomData<I>,
786 o: core::marker::PhantomData<O>,
787 e: core::marker::PhantomData<E>,
788}
789
790impl<F, I, O, E, C> Context<F, I, O, E, C>
791where
792 F: Parser<I, O, E>,
793 I: Stream,
794 E: ContextError<I, C>,
795 C: Clone + crate::lib::std::fmt::Debug,
796{
797 pub(crate) fn new(parser: F, context: C) -> Self {
798 Self {
799 parser,
800 context,
801 i: Default::default(),
802 o: Default::default(),
803 e: Default::default(),
804 }
805 }
806}
807
808impl<F, I, O, E, C> Parser<I, O, E> for Context<F, I, O, E, C>
809where
810 F: Parser<I, O, E>,
811 I: Stream,
812 E: ContextError<I, C>,
813 C: Clone + crate::lib::std::fmt::Debug,
814{
815 fn parse_next(&mut self, i: I) -> IResult<I, O, E> {
816 #[cfg(feature = "debug")]
817 let name = format!("context={:?}", self.context);
818 #[cfg(not(feature = "debug"))]
819 let name: &str = "context";
820 trace(name, move |i: I| {
821 (self.parser)
822 .parse_next(i.clone())
823 .map_err(|err| err.map(|err| err.add_context(i, self.context.clone())))
824 })
825 .parse_next(input:i)
826 }
827}
828