Migrated OrDefaultParser to MapDecorator

Author: ngeor

rusty_pc/src/map_decorator.rs

@@ -16,6 +16,12 @@ where
 
     /// Maps the successful result of the parser.
     fn map_ok(&self, ok: Self::OriginalOutput) -> Self::Output;
+
+    /// Maps the soft error of the parser.
+    /// By default, the error is returned as-is. However, it is possible to override this behavior.
+    fn map_soft_error(&self, err: Self::Error) -> Result<Self::Output, Self::Error> {
+        Err(err)
+    }
 }
 
 /// Marker trait for `MapDecorator`.
@@ -33,6 +39,7 @@ where
     fn parse(&mut self, input: &mut I) -> Result<Self::Output, Self::Error> {
         match self.decorated().parse(input) {
             Ok(ok) => Ok(self.map_ok(ok)),
+            Err(err) if err.is_soft() => self.map_soft_error(err),
             Err(err) => Err(err),
         }
     }

rusty_pc/src/or_default.rs

@@ -1,30 +1,39 @@
-use crate::{InputTrait, Parser, ParserErrorTrait};
+use crate::map_decorator::{MapDecorator, MapDecoratorMarker};
+use crate::{InputTrait, Parser};
 
 pub struct OrDefaultParser<P> {
     parser: P,
 }
+
 impl<P> OrDefaultParser<P> {
     pub(crate) fn new(parser: P) -> Self {
         Self { parser }
     }
 }
-impl<I, C, P> Parser<I, C> for OrDefaultParser<P>
+
+impl<I, C, P> MapDecorator<I, C> for OrDefaultParser<P>
 where
     I: InputTrait,
     P: Parser<I, C>,
     P::Output: Default,
 {
+    type OriginalOutput = P::Output;
     type Output = P::Output;
     type Error = P::Error;
-    fn parse(&mut self, input: &mut I) -> Result<Self::Output, Self::Error> {
-        match self.parser.parse(input) {
-            Ok(value) => Ok(value),
-            Err(err) if err.is_soft() => Ok(P::Output::default()),
-            Err(err) => Err(err),
-        }
+
+    fn decorated(
+        &mut self,
+    ) -> &mut impl Parser<I, C, Output = Self::OriginalOutput, Error = Self::Error> {
+        &mut self.parser
     }
 
-    fn set_context(&mut self, ctx: &C) {
-        self.parser.set_context(ctx)
+    fn map_ok(&self, ok: Self::OriginalOutput) -> Self::Output {
+        ok
+    }
+
+    fn map_soft_error(&self, _err: Self::Error) -> Result<Self::Output, Self::Error> {
+        Ok(P::Output::default())
     }
 }
+
+impl<P> MapDecoratorMarker for OrDefaultParser<P> {}