vendor/pest/src/iterators/flat_pairs.rs

   1 // pest. The Elegant Parser
   2 // Copyright (c) 2018 Dragoș Tiselice
   3 //
   4 // Licensed under the Apache License, Version 2.0
   5 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
   6 // license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   7 // option. All files in the project carrying such notice may not be copied,
   8 // modified, or distributed except according to those terms.
   9
  10 use std::fmt;
  11 use std::rc::Rc;
  12
  13 use super::pair::{self, Pair};
  14 use super::queueable_token::QueueableToken;
  15 use super::tokens::{self, Tokens};
  16 use RuleType;
  17
  18 /// An iterator over [`Pair`]s. It is created by [`Pairs::flatten`].
  19 ///
  20 /// [`Pair`]: struct.Pair.html
  21 /// [`Pairs::flatten`]: struct.Pairs.html#method.flatten
  22 pub struct FlatPairs<'i, R> {
  23     queue: Rc<Vec<QueueableToken<R>>>,
  24     input: &'i str,
  25     start: usize,
  26     end: usize,
  27 }
  28
  29 pub fn new<R: RuleType>(
  30     queue: Rc<Vec<QueueableToken<R>>>,
  31     input: &str,
  32     start: usize,
  33     end: usize,
  34 ) -> FlatPairs<R> {
  35     FlatPairs {
  36         queue,
  37         input,
  38         start,
  39         end,
  40     }
  41 }
  42
  43 impl<'i, R: RuleType> FlatPairs<'i, R> {
  44     /// Returns the `Tokens` for these pairs.
  45     ///
  46     /// # Examples
  47     ///
  48     /// ```
  49     /// # use std::rc::Rc;
  50     /// # use pest;
  51     /// # #[allow(non_camel_case_types)]
  52     /// # #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
  53     /// enum Rule {
  54     ///     a
  55     /// }
  56     ///
  57     /// let input = "";
  58     /// let pairs = pest::state(input, |state| {
  59     ///     // generating Token pair with Rule::a ...
  60     /// #     state.rule(Rule::a, |s| Ok(s))
  61     /// }).unwrap();
  62     /// let tokens: Vec<_> = pairs.flatten().tokens().collect();
  63     ///
  64     /// assert_eq!(tokens.len(), 2);
  65     /// ```
  66     #[inline]
  67     pub fn tokens(self) -> Tokens<'i, R> {
  68         tokens::new(self.queue, self.input, self.start, self.end)
  69     }
  70
  71     fn next_start(&mut self) {
  72         self.start += 1;
  73
  74         while self.start < self.end && !self.is_start(self.start) {
  75             self.start += 1;
  76         }
  77     }
  78
  79     fn next_start_from_end(&mut self) {
  80         self.end -= 1;
  81
  82         while self.end >= self.start && !self.is_start(self.end) {
  83             self.end -= 1;
  84         }
  85     }
  86
  87     fn is_start(&self, index: usize) -> bool {
  88         match self.queue[index] {
  89             QueueableToken::Start { .. } => true,
  90             QueueableToken::End { .. } => false,
  91         }
  92     }
  93 }
  94
  95 impl<'i, R: RuleType> Iterator for FlatPairs<'i, R> {
  96     type Item = Pair<'i, R>;
  97
  98     fn next(&mut self) -> Option<Self::Item> {
  99         if self.start >= self.end {
 100             return None;
 101         }
 102
 103         let pair = pair::new(Rc::clone(&self.queue), self.input, self.start);
 104
 105         self.next_start();
 106
 107         Some(pair)
 108     }
 109 }
 110
 111 impl<'i, R: RuleType> DoubleEndedIterator for FlatPairs<'i, R> {
 112     fn next_back(&mut self) -> Option<Self::Item> {
 113         if self.end <= self.start {
 114             return None;
 115         }
 116
 117         self.next_start_from_end();
 118
 119         let pair = pair::new(Rc::clone(&self.queue), self.input, self.end);
 120
 121         Some(pair)
 122     }
 123 }
 124
 125 impl<'i, R: RuleType> fmt::Debug for FlatPairs<'i, R> {
 126     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 127         f.debug_struct("FlatPairs")
 128             .field("pairs", &self.clone().collect::<Vec<_>>())
 129             .finish()
 130     }
 131 }
 132
 133 impl<'i, R: Clone> Clone for FlatPairs<'i, R> {
 134     fn clone(&self) -> FlatPairs<'i, R> {
 135         FlatPairs {
 136             queue: Rc::clone(&self.queue),
 137             input: self.input,
 138             start: self.start,
 139             end: self.end,
 140         }
 141     }
 142 }
 143
 144 #[cfg(test)]
 145 mod tests {
 146     use super::super::super::macros::tests::*;
 147     use super::super::super::Parser;
 148
 149     #[test]
 150     fn iter_for_flat_pairs() {
 151         let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
 152
 153         assert_eq!(
 154             pairs.flatten().map(|p| p.as_rule()).collect::<Vec<Rule>>(),
 155             vec![Rule::a, Rule::b, Rule::c]
 156         );
 157     }
 158
 159     #[test]
 160     fn double_ended_iter_for_flat_pairs() {
 161         let pairs = AbcParser::parse(Rule::a, "abcde").unwrap();
 162         assert_eq!(
 163             pairs
 164                 .flatten()
 165                 .rev()
 166                 .map(|p| p.as_rule())
 167                 .collect::<Vec<Rule>>(),
 168             vec![Rule::c, Rule::b, Rule::a]
 169         );
 170     }
 171 }