combine/stream/
state.rs

1use crate::{
2    error::ParseResult,
3    stream::{Positioned, RangeStreamOnce, ResetStream, StreamErrorFor, StreamOnce},
4};
5
6#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
7pub struct Stream<S, U> {
8    pub stream: S,
9    pub state: U,
10}
11
12impl<S, U> Positioned for Stream<S, U>
13where
14    S: Positioned,
15{
16    #[inline]
17    fn position(&self) -> Self::Position {
18        self.stream.position()
19    }
20}
21
22impl<S, U> ResetStream for Stream<S, U>
23where
24    S: ResetStream,
25{
26    type Checkpoint = S::Checkpoint;
27
28    #[inline]
29    fn checkpoint(&self) -> Self::Checkpoint {
30        self.stream.checkpoint()
31    }
32
33    #[inline]
34    fn reset(&mut self, checkpoint: Self::Checkpoint) -> Result<(), Self::Error> {
35        self.stream.reset(checkpoint)
36    }
37}
38
39impl<S, U> StreamOnce for Stream<S, U>
40where
41    S: StreamOnce,
42{
43    type Token = S::Token;
44    type Range = S::Range;
45    type Position = S::Position;
46    type Error = S::Error;
47
48    #[inline]
49    fn uncons(&mut self) -> Result<S::Token, StreamErrorFor<Self>> {
50        self.stream.uncons()
51    }
52
53    fn is_partial(&self) -> bool {
54        self.stream.is_partial()
55    }
56}
57
58impl<S, U> RangeStreamOnce for Stream<S, U>
59where
60    S: RangeStreamOnce,
61{
62    #[inline]
63    fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>> {
64        self.stream.uncons_range(size)
65    }
66
67    #[inline]
68    fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
69    where
70        F: FnMut(Self::Token) -> bool,
71    {
72        self.stream.uncons_while(f)
73    }
74
75    fn uncons_while1<F>(&mut self, f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
76    where
77        F: FnMut(Self::Token) -> bool,
78    {
79        self.stream.uncons_while1(f)
80    }
81
82    #[inline]
83    fn distance(&self, end: &Self::Checkpoint) -> usize {
84        self.stream.distance(end)
85    }
86
87    #[inline]
88    fn range(&self) -> Self::Range {
89        self.stream.range()
90    }
91}