Implement check_exit_matcher.

src/context/parser_context.rs

@@ -1,10 +1,13 @@
 use nom::combinator::eof;
+use nom::IResult;
 
 use super::exiting::ExitClass;
 use super::global_settings::GlobalSettings;
 use super::list::List;
 use super::DynContextMatcher;
 use super::RefContext;
+use crate::error::CustomError;
+use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::OrgSource;
 use crate::types::Object;
@@ -169,6 +172,56 @@ impl<'r, 's> Context<'r, 's> {
             tree: parent_tree.clone(),
         })
     }
+
+    pub fn get_data(&self) -> &ContextElement<'r, 's> {
+        self.tree.get_data()
+    }
+
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
+    pub fn check_exit_matcher(
+        &'r self,
+        i: OrgSource<'s>,
+    ) -> IResult<OrgSource<'s>, OrgSource<'s>, CustomError<OrgSource<'s>>> {
+        let mut current_class_filter = ExitClass::Gamma;
+        for current_node in self.iter_context() {
+            let context_element = current_node.get_data();
+            match context_element {
+                ContextElement::ExitMatcherNode(exit_matcher) => {
+                    if exit_matcher.class as u32 <= current_class_filter as u32 {
+                        current_class_filter = exit_matcher.class;
+                        let local_result = (exit_matcher.exit_matcher)(&current_node, i);
+                        if local_result.is_ok() {
+                            return local_result;
+                        }
+                    }
+                }
+                _ => {}
+            };
+        }
+        // TODO: Make this a specific error instead of just a generic MyError
+        return Err(nom::Err::Error(CustomError::MyError(MyError(
+            "NoExit".into(),
+        ))));
+    }
+
+    /// Indicates if elements should consume the whitespace after them.
+    ///
+    /// Defaults to true.
+    pub fn should_consume_trailing_whitespace(&self) -> bool {
+        self._should_consume_trailing_whitespace().unwrap_or(true)
+    }
+
+    fn _should_consume_trailing_whitespace(&self) -> Option<bool> {
+        for current_node in self.iter() {
+            match current_node {
+                ContextElement::ConsumeTrailingWhitespace(should) => {
+                    return Some(*should);
+                }
+                _ => {}
+            }
+        }
+        None
+    }
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]