Struct casbin::Enforcer

pub struct Enforcer { /* fields omitted */ }

Enforcer is the main interface for authorization enforcement and policy management.

Trait Implementations

impl CoreApi for Enforcer

fn new<'async_trait, M: TryIntoModel, A: TryIntoAdapter>(
    m: M,
    a: A
) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>> where
    M: 'async_trait,
    A: 'async_trait,
    Self: 'async_trait, 

fn add_function(&mut self, fname: &str, f: fn(_: String, _: String) -> bool)

fn get_model(&self) -> &dyn Model

fn get_mut_model(&mut self) -> &mut dyn Model

fn get_adapter(&self) -> &dyn Adapter

fn get_mut_adapter(&mut self) -> &mut dyn Adapter

fn set_watcher(&mut self, w: Box<dyn Watcher>)

fn get_role_manager(&self) -> Arc<RwLock<dyn RoleManager>>

fn set_role_manager(&mut self, rm: Arc<RwLock<dyn RoleManager>>)

fn add_matching_fn(&mut self, f: fn(_: String, _: String) -> bool) -> Result<()>

fn set_model<'life0, 'async_trait, M: TryIntoModel>(
    &'life0 mut self,
    m: M
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    M: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

fn set_adapter<'life0, 'async_trait, A: TryIntoAdapter>(
    &'life0 mut self,
    a: A
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    A: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

fn set_effector(&mut self, e: Box<dyn Effector>)

fn enforce<'life0, 'life1, 'async_trait, S: AsRef<str> + Send + Sync>(
    &'life0 mut self,
    rvals: &'life1 [S]
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>> where
    S: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Enforce decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (sub, obj, act).

Examples

use casbin::prelude::*;
#[cfg(feature = "runtime-async-std")]
#[async_std::main]
async fn main() {
    let mut e = Enforcer::new("examples/basic_model.conf", "examples/basic_policy.csv").await.unwrap();
    assert_eq!(true, e.enforce(&["alice", "data1", "read"]).await.unwrap());
}

#[cfg(feature = "runtime-tokio")]
#[tokio::main]
async fn main() {
    let mut e = Enforcer::new("examples/basic_model.conf", "examples/basic_policy.csv").await.unwrap();
    assert_eq!(true, e.enforce(&["alice", "data1", "read"]).await.unwrap());
}
#[cfg(all(not(feature = "runtime-async-std"), not(feature = "runtime-tokio")))]
fn main() {}

fn build_role_links(&mut self) -> Result<()>

fn load_policy<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

fn save_policy<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

fn clear_policy(&mut self)

fn enable_enforce(&mut self, enabled: bool)

fn enable_auto_save(&mut self, auto_save: bool)

fn enable_auto_build_role_links(&mut self, auto_build_role_links: bool)

fn has_auto_save_enabled(&self) -> bool

impl InternalApi for Enforcer

fn add_policy_internal<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 mut self,
    sec: &'life1 str,
    ptype: &'life2 str,
    rule: Vec<String>
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

fn add_policies_internal<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 mut self,
    sec: &'life1 str,
    ptype: &'life2 str,
    rules: Vec<Vec<String>>
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

fn remove_policy_internal<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 mut self,
    sec: &'life1 str,
    ptype: &'life2 str,
    rule: Vec<String>
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

fn remove_policies_internal<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 mut self,
    sec: &'life1 str,
    ptype: &'life2 str,
    rules: Vec<Vec<String>>
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

fn remove_filtered_policy_internal<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 mut self,
    sec: &'life1 str,
    ptype: &'life2 str,
    field_index: usize,
    field_values: Vec<String>
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait,