ellmau/adf-obdd
1
0
Fork 0
mirror of https://github.com/ellmau/adf-obdd.git synced 2025-12-20 09:39:38 +01:00
Code Issues Projects Releases Wiki Activity

Make AdfParser publically accessible

Browse Source
This commit is contained in:
monsterkrampe 2025-06-05 10:36:39 +02:00
parent 8b16cb0825
commit b507fe22ce
No known key found for this signature in database
GPG Key ID: B8ADC1F5A5CE5057
1 changed files with 25 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
lib/src/parser.rs
View File

@ -20,28 +20,28 @@ use crate::datatypes::adf::VarContainer;
/// A representation of a formula, still using the strings from the input. /// A representation of a formula, still using the strings from the input.
#[derive(Clone, PartialEq, Eq)] #[derive(Clone, PartialEq, Eq)]
pub enum Formula<'a> { pub enum Formula {
/// `c(f)` in the input format. /// `c(f)` in the input format.
Bot, Bot,
/// `c(v)` in the input format. /// `c(v)` in the input format.
Top, Top,
/// Some atomic variable in the input format. /// Some atomic variable in the input format.
Atom(&'a str), Atom(String),
/// Negation of a subformula. /// Negation of a subformula.
Not(Box<Formula<'a>>), Not(Box<Formula>),
/// Conjunction of two subformulae. /// Conjunction of two subformulae.
And(Box<Formula<'a>>, Box<Formula<'a>>), And(Box<Formula>, Box<Formula>),
/// Disjunction of two subformulae. /// Disjunction of two subformulae.
Or(Box<Formula<'a>>, Box<Formula<'a>>), Or(Box<Formula>, Box<Formula>),
/// Implication of two subformulae. /// Implication of two subformulae.
Imp(Box<Formula<'a>>, Box<Formula<'a>>), Imp(Box<Formula>, Box<Formula>),
/// Exclusive-Or of two subformulae. /// Exclusive-Or of two subformulae.
Xor(Box<Formula<'a>>, Box<Formula<'a>>), Xor(Box<Formula>, Box<Formula>),
/// If and only if connective between two formulae. /// If and only if connective between two formulae.
Iff(Box<Formula<'a>>, Box<Formula<'a>>), Iff(Box<Formula>, Box<Formula>),
} }
impl Formula<'_> { impl Formula {
pub(crate) fn to_boolean_expr( pub(crate) fn to_boolean_expr(
&self, &self,
) -> biodivine_lib_bdd::boolean_expression::BooleanExpression { ) -> biodivine_lib_bdd::boolean_expression::BooleanExpression {
@ -90,7 +90,7 @@ impl Formula<'_> {
} }
} }
impl std::fmt::Debug for Formula<'_> { impl std::fmt::Debug for Formula {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self { match self {
Formula::Atom(a) => { Formula::Atom(a) => {
@ -132,14 +132,14 @@ impl std::fmt::Debug for Formula<'_> {
/// ///
/// Note that the parser can be utilised by an [ADF][`crate::adf::Adf`] to initialise it with minimal overhead. /// Note that the parser can be utilised by an [ADF][`crate::adf::Adf`] to initialise it with minimal overhead.
#[derive(Debug)] #[derive(Debug)]
pub struct AdfParser<'a> { pub struct AdfParser {
namelist: Arc<RwLock<Vec<String>>>, pub namelist: Arc<RwLock<Vec<String>>>,
dict: Arc<RwLock<HashMap<String, usize>>>, pub dict: Arc<RwLock<HashMap<String, usize>>>,
formulae: RefCell<Vec<Formula<'a>>>, pub formulae: RefCell<Vec<Formula>>,
formulaname: RefCell<Vec<String>>, pub formulaname: RefCell<Vec<String>>,
} }
impl Default for AdfParser<'_> { impl Default for AdfParser {
fn default() -> Self { fn default() -> Self {
AdfParser { AdfParser {
namelist: Arc::new(RwLock::new(Vec::new())), namelist: Arc::new(RwLock::new(Vec::new())),
@ -150,10 +150,7 @@ impl Default for AdfParser<'_> {
} }
} }
impl<'a, 'b> AdfParser<'b> impl<'a> AdfParser {
where
'a: 'b,
{
#[allow(dead_code)] #[allow(dead_code)]
fn parse_statements(&'a self) -> impl FnMut(&'a str) -> IResult<&'a str, ()> { fn parse_statements(&'a self) -> impl FnMut(&'a str) -> IResult<&'a str, ()> {
move |input| { move |input| {
@ -212,9 +209,9 @@ where
} }
} }
impl<'a> AdfParser<'a> { impl AdfParser {
/// Creates a new parser, utilising the already existing [VarContainer] /// Creates a new parser, utilising the already existing [VarContainer]
pub fn with_var_container(var_container: VarContainer) -> AdfParser<'a> { pub fn with_var_container(var_container: VarContainer) -> AdfParser {
AdfParser { AdfParser {
namelist: var_container.names(), namelist: var_container.names(),
dict: var_container.mappings(), dict: var_container.mappings(),
@ -224,7 +221,7 @@ impl<'a> AdfParser<'a> {
} }
} }
impl AdfParser<'_> { impl AdfParser {
/// after an update to the namelist, all indizes are updated /// after an update to the namelist, all indizes are updated
fn regenerate_indizes(&self) { fn regenerate_indizes(&self) {
self.namelist self.namelist
@ -284,7 +281,7 @@ impl AdfParser<'_> {
} }
fn atomic_term(input: &str) -> IResult<&str, Formula> { fn atomic_term(input: &str) -> IResult<&str, Formula> {
AdfParser::atomic(input).map(|(input, result)| (input, Formula::Atom(result))) AdfParser::atomic(input).map(|(input, result)| (input, Formula::Atom(result.to_string())))
} }
fn formula(input: &str) -> IResult<&str, Formula> { fn formula(input: &str) -> IResult<&str, Formula> {
@ -504,7 +501,10 @@ mod test {
assert_eq!(parser.dict_value("b"), Some(2usize)); assert_eq!(parser.dict_value("b"), Some(2usize));
assert_eq!( assert_eq!(
format!("{:?}", parser.ac_at(1).unwrap()), format!("{:?}", parser.ac_at(1).unwrap()),
format!("{:?}", Formula::Not(Box::new(Formula::Atom("a")))) format!(
"{:?}",
Formula::Not(Box::new(Formula::Atom("a".to_string())))
)
); );
assert_eq!(parser.formula_count(), 3); assert_eq!(parser.formula_count(), 3);
assert_eq!(parser.formula_order(), vec![0, 2, 1]); assert_eq!(parser.formula_order(), vec![0, 2, 1]);