finish effector stream (#145)

* finish effector stream

* simplify code

* bump version

* add assert to make sure that when we call current it's already finished

* Fix: clippy warnings

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "casbin"
-version = "0.7.6"
+version = "0.8.1"
 authors = ["Joey <[email protected]>", "Cheng JIANG <[email protected]>"]
 edition = "2018"
 license = "Apache-2.0"

README.md

@@ -27,7 +27,7 @@ Add this package to `Cargo.toml` of your project. (Check https://crates.io/crate
 
 ```toml
 [dependencies]
-casbin = { version = "0.7.6", default-features = false, features = ["runtime-async-std", "logging"] }
+casbin = { version = "0.8.1", default-features = false, features = ["runtime-async-std", "logging"] }
 async-std = { version = "1.5.0", features = ["attributes"] }
 env_logger = "0.7.1"
 ```

src/effector.rs

@@ -1,67 +1,88 @@
-pub trait Effector: Send + Sync {
-    fn merge_effects(&self, expr: &str, effects: Vec<EffectKind>) -> bool;
-}
-
-#[derive(PartialEq, Clone)]
+#[derive(PartialEq, Clone, Copy)]
 pub enum EffectKind {
     Allow = 0,
     Indeterminate = 1,
     Deny = 2,
 }
 
+pub trait Effector: Send + Sync {
+    fn new_stream(&self, expr: &str, cap: usize) -> Box<dyn EffectorStream>;
+}
+
+pub trait EffectorStream: Send + Sync {
+    fn current(&self) -> bool;
+    fn push_effect(&mut self, eft: EffectKind) -> (bool, bool);
+}
+
+pub struct DefaultEffectStream {
+    done: bool,
+    res: bool,
+    expr: String,
+    effects: Vec<EffectKind>,
+}
+
 #[derive(Default)]
 pub struct DefaultEffector;
 
 impl Effector for DefaultEffector {
-    fn merge_effects(&self, expr: &str, effects: Vec<EffectKind>) -> bool {
-        if expr == "some(where (p_eft == allow))" {
-            let mut result = false;
-            for eft in effects {
-                if eft == EffectKind::Allow {
-                    result = true;
-                    break;
-                }
-            }
+    fn new_stream(&self, expr: &str, cap: usize) -> Box<dyn EffectorStream> {
+        let res = match &*expr {
+            "some(where (p_eft == allow))"
+            | "some(where (p_eft == allow)) && !some(where (p_eft == deny))"
+            | "priority(p_eft) || deny" => false,
+            "!some(where (p_eft == deny))" => true,
+            _ => panic!("unsupported effect: `{}`", expr),
+        };
 
-            result
-        } else if expr == "!some(where (p_eft == deny))" {
-            let mut result = true;
-            for eft in effects {
-                if eft == EffectKind::Deny {
-                    result = false;
-                    break;
-                }
-            }
+        Box::new(DefaultEffectStream {
+            done: false,
+            res,
+            expr: expr.to_owned(),
+            effects: Vec::with_capacity(cap),
+        })
+    }
+}
 
-            result
-        } else if expr == "some(where (p_eft == allow)) && !some(where (p_eft == deny))" {
-            let mut result = false;
-            for eft in effects {
-                if eft == EffectKind::Allow {
-                    result = true;
-                } else if eft == EffectKind::Deny {
-                    result = false;
-                    break;
-                }
-            }
+impl EffectorStream for DefaultEffectStream {
+    fn current(&self) -> bool {
+        assert!(self.done);
+        self.res
+    }
+
+    fn push_effect(&mut self, eft: EffectKind) -> (bool, bool) {
+        let cap = self.effects.capacity();
+        self.effects.push(eft);
 
-            result
-        } else if expr == "priority(p_eft) || deny" {
-            let mut result = false;
-            for eft in effects {
-                if eft != EffectKind::Indeterminate {
-                    if eft == EffectKind::Allow {
-                        result = true
-                    } else {
-                        result = false
-                    }
-                    break;
-                }
+        if self.expr == "some(where (p_eft == allow))" {
+            if eft == EffectKind::Allow {
+                self.done = true;
+                self.res = true;
             }
+        } else if self.expr == "some(where (p_eft == allow)) && !some(where (p_eft == deny))" {
+            if eft == EffectKind::Allow {
+                self.res = true;
+            } else if eft == EffectKind::Deny {
+                self.done = true;
+                self.res = false;
+            }
+        } else if self.expr == "!some(where (p_eft == deny))" {
+            if eft == EffectKind::Deny {
+                self.done = true;
+                self.res = false;
+            }
+        } else if self.expr == "priority(p_eft) || deny" && eft != EffectKind::Indeterminate {
+            if eft == EffectKind::Allow {
+                self.res = true;
+            } else {
+                self.res = false;
+            }
+            self.done = true;
+        }
 
-            result
-        } else {
-            panic!("unsupported effect: `{}`", expr);
+        if cap == self.effects.len() {
+            self.done = true;
         }
+
+        (self.done, self.res)
     }
 }

src/enforcer.rs

@@ -144,13 +144,14 @@ impl Enforcer {
             }
         }
 
-        let mut policy_effects: Vec<EffectKind> = vec![];
         let policies = p_ast.get_policy();
         let policy_len = policies.len();
+        let mut eft_stream = self
+            .eft
+            .new_stream(&e_ast.value, if policy_len > 0 { policy_len } else { 1 });
         let scope_size = scope.len();
 
         if policy_len != 0 {
-            policy_effects = vec![EffectKind::Deny; policy_len];
             for (i, pvals) in policies.iter().enumerate() {
                 if i != 0 {
                     scope.rewind(scope_size);
@@ -175,34 +176,30 @@ impl Enforcer {
                 let eval_result = self
                     .engine
                     .eval_with_scope::<bool>(&mut scope, &expstring)?;
-                if !eval_result {
-                    policy_effects[i] = EffectKind::Indeterminate;
-                    continue;
-                }
-                if let Some(j) = p_ast.tokens.iter().position(|x| x == "p_eft") {
-                    let eft = &pvals[j];
-                    if eft == "allow" {
-                        policy_effects[i] = EffectKind::Allow;
-                    } else if eft == "deny" {
-                        policy_effects[i] = EffectKind::Deny;
+                let mut eft = if !eval_result {
+                    EffectKind::Indeterminate
+                } else {
+                    EffectKind::Allow
+                };
+                eft = if eft == EffectKind::Indeterminate {
+                    EffectKind::Indeterminate
+                } else if let Some(j) = p_ast.tokens.iter().position(|x| x == "p_eft") {
+                    let p_eft = &pvals[j];
+                    if p_eft == "allow" {
+                        EffectKind::Allow
+                    } else if p_eft == "deny" {
+                        EffectKind::Deny
                     } else {
-                        policy_effects[i] = EffectKind::Indeterminate;
+                        EffectKind::Indeterminate
                     }
                 } else {
-                    policy_effects[i] = EffectKind::Allow;
-                }
-                if e_ast.value == "priority(p_eft) || deny" {
-                    break;
-                } else if e_ast.value == "some(where (p_eft == allow))"
-                    && policy_effects[i] == EffectKind::Allow
-                {
-                    return Ok(true);
-                } else if policy_effects[i] == EffectKind::Deny
-                    && (e_ast.value == "!some(where (p_eft == deny))"
-                        || e_ast.value
-                            == "some(where (p_eft == allow)) && !some(where (p_eft == deny))")
-                {
-                    return Ok(false);
+                    EffectKind::Allow
+                };
+                match eft_stream.push_effect(eft) {
+                    (true, res) => {
+                        return Ok(res);
+                    }
+                    (false, _) => continue,
                 }
             }
         } else {
@@ -212,14 +209,15 @@ impl Enforcer {
             let eval_result = self
                 .engine
                 .eval_with_scope::<bool>(&mut scope, &m_ast.value)?;
-            if eval_result {
-                policy_effects.push(EffectKind::Allow);
+            let eft = if eval_result {
+                EffectKind::Allow
             } else {
-                policy_effects.push(EffectKind::Indeterminate);
-            }
+                EffectKind::Indeterminate
+            };
+            eft_stream.push_effect(eft);
         }
 
-        Ok(self.eft.merge_effects(&e_ast.value, policy_effects))
+        Ok(eft_stream.current())
     }
 }
 

src/lib.rs

@@ -37,7 +37,7 @@ pub use cached_api::CachedApi;
 pub use cached_enforcer::CachedEnforcer;
 pub use convert::{TryIntoAdapter, TryIntoModel};
 pub use core_api::CoreApi;
-pub use effector::{DefaultEffector, EffectKind, Effector};
+pub use effector::{DefaultEffectStream, DefaultEffector, EffectKind, Effector, EffectorStream};
 pub use emitter::{Event, EventData, EventEmitter, EventKey};
 pub use enforcer::Enforcer;
 pub use error::Error;