From f1a4d315de5be701f29beb7d3c32af2e96f967b6 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 10 Sep 2019 17:41:40 +0200 Subject: No need to force user data to be a reference --- pest_consume/src/lib.rs | 103 +++++++++++++++++++++++------------------------- 1 file changed, 50 insertions(+), 53 deletions(-) (limited to 'pest_consume/src/lib.rs') diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs index 701fbba..425d8cf 100644 --- a/pest_consume/src/lib.rs +++ b/pest_consume/src/lib.rs @@ -6,8 +6,6 @@ use pest::RuleType; pub use pest_consume_macros::match_inputs; pub use pest_consume_macros::parser; -static UNIT: () = (); - mod node { use super::Parser; use pest::error::{Error, ErrorVariant}; @@ -16,22 +14,22 @@ mod node { use pest::{RuleType, Span}; /// Carries a pest Pair alongside custom user data. - #[derive(Debug)] - pub struct Node<'input, 'data, Rule: RuleType, Data> { + #[derive(Debug, Clone)] + pub struct Node<'input, Rule: RuleType, Data> { pair: Pair<'input, Rule>, - user_data: &'data Data, + user_data: Data, } /// Iterator over `Node`s. It is created by `Node::children` or `Nodes::new`. - #[derive(Debug)] - pub struct Nodes<'input, 'data, Rule: RuleType, Data> { + #[derive(Debug, Clone)] + pub struct Nodes<'input, Rule: RuleType, Data> { pairs: Pairs<'input, Rule>, span: Span<'input>, - user_data: &'data Data, + user_data: Data, } - impl<'i, 'd, R: RuleType, D> Node<'i, 'd, R, D> { - pub fn new(pair: Pair<'i, R>, user_data: &'d D) -> Self { + impl<'i, R: RuleType, D> Node<'i, R, D> { + pub fn new(pair: Pair<'i, R>, user_data: D) -> Self { Node { pair, user_data } } /// Create an error that points to the span of the input. @@ -42,14 +40,20 @@ mod node { ) } /// Reconstruct the input with a new pair, passing the user data along. - pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self { + pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self + where + D: Clone, + { Node { pair: new_pair, - user_data: self.user_data, + user_data: self.user_data.clone(), } } /// If the contained pair has exactly one child, return a new Self containing it. - pub fn single_child(&self) -> Option { + pub fn single_child(&self) -> Option + where + D: Clone, + { let mut children = self.pair.clone().into_inner(); if let Some(child) = children.next() { if children.next().is_none() { @@ -61,7 +65,10 @@ mod node { /// Return an iterator over the children of this input // Can't use `-> impl Iterator` because of weird lifetime limitations // (see https://github.com/rust-lang/rust/issues/61997). - pub fn children(&self) -> Nodes<'i, 'd, R, D> { + pub fn children(&self) -> Nodes<'i, R, D> + where + D: Clone, + { Nodes { pairs: self.as_pair().clone().into_inner(), span: self.as_span(), @@ -69,8 +76,11 @@ mod node { } } - pub fn user_data(&self) -> &'d D { - self.user_data + pub fn user_data(&self) -> D + where + D: Clone, + { + self.user_data.clone() } pub fn as_pair(&self) -> &Pair<'i, R> { &self.pair @@ -93,13 +103,9 @@ mod node { } } - impl<'i, 'd, R: RuleType, D> Nodes<'i, 'd, R, D> { + impl<'i, R: RuleType, D> Nodes<'i, R, D> { /// `input` must be the _original_ input that `pairs` is pointing to. - pub fn new( - input: &'i str, - pairs: Pairs<'i, R>, - user_data: &'d D, - ) -> Self { + pub fn new(input: &'i str, pairs: Pairs<'i, R>, user_data: D) -> Self { let span = Span::new(input, 0, input.len()).unwrap(); Nodes { pairs, @@ -116,19 +122,27 @@ mod node { } pub fn aliased_rules(&self) -> Vec where + D: Clone, C: Parser, ::Parser: PestParser, { self.clone().map(|p| p.as_aliased_rule::()).collect() } /// Reconstruct the input with a new pair, passing the user data along. - fn with_pair(&self, new_pair: Pair<'i, R>) -> Node<'i, 'd, R, D> { - Node::new(new_pair, self.user_data) + fn with_pair(&self, new_pair: Pair<'i, R>) -> Node<'i, R, D> + where + D: Clone, + { + Node::new(new_pair, self.user_data.clone()) } } - impl<'i, 'd, R: RuleType, D> Iterator for Nodes<'i, 'd, R, D> { - type Item = Node<'i, 'd, R, D>; + impl<'i, R, D> Iterator for Nodes<'i, R, D> + where + R: RuleType, + D: Clone, + { + type Item = Node<'i, R, D>; fn next(&mut self) -> Option { let child_pair = self.pairs.next()?; @@ -137,34 +151,17 @@ mod node { } } - impl<'i, 'd, R: RuleType, D> DoubleEndedIterator for Nodes<'i, 'd, R, D> { + impl<'i, R, D> DoubleEndedIterator for Nodes<'i, R, D> + where + R: RuleType, + D: Clone, + { fn next_back(&mut self) -> Option { let child_pair = self.pairs.next_back()?; let child = self.with_pair(child_pair); Some(child) } } - - // Manual impl to avoid stupid `D: Clone` trait bound - impl<'i, 'd, R: RuleType, D> Clone for Node<'i, 'd, R, D> { - fn clone(&self) -> Self { - Node { - pair: self.pair.clone(), - user_data: self.user_data, - } - } - } - - // Manual impl to avoid stupid `D: Clone` trait bound - impl<'i, 'd, R: RuleType, D> Clone for Nodes<'i, 'd, R, D> { - fn clone(&self) -> Self { - Nodes { - pairs: self.pairs.clone(), - span: self.span.clone(), - user_data: self.user_data, - } - } - } } pub use node::{Node, Nodes}; @@ -183,16 +180,16 @@ pub trait Parser { fn parse<'i>( rule: Self::Rule, input_str: &'i str, - ) -> Result, Error> { - Self::parse_with_userdata(rule, input_str, &UNIT) + ) -> Result, Error> { + Self::parse_with_userdata(rule, input_str, ()) } /// Parses a `&str` starting from `rule`, carrying `user_data` through the parser methods. - fn parse_with_userdata<'i, 'd, D>( + fn parse_with_userdata<'i, D>( rule: Self::Rule, input_str: &'i str, - user_data: &'d D, - ) -> Result, Error> { + user_data: D, + ) -> Result, Error> { let pairs = Self::Parser::parse(rule, input_str)?; Ok(Nodes::new(input_str, pairs, user_data)) } -- cgit v1.2.3