Struct NotPolicy 

pub struct NotPolicy<D: PolicyDomain> { /* private fields */ }

Inverts the decision of an inner policy.

Implementations

impl<D: PolicyDomain> NotPolicy<D>

pub fn new(policy: impl Policy<D> + 'static) -> Self

Creates a new NotPolicy that inverts the given policy’s decision.

Examples found in repository

examples/deny_override.rs (line 275)

async fn scoped_exclusion_demo() {
    #[derive(Debug, Clone)]
    struct Member {
        is_owner: bool,
        is_collaborator: bool,
        muted: bool,
    }
    #[derive(Debug, Clone)]
    struct Thread;

    struct ThreadDomain;

    impl PolicyDomain for ThreadDomain {
        type Subject = Member;
        type Action = Access;
        type Resource = Thread;
        type Context = ();
    }

    let owner_policy = PolicyBuilder::<ThreadDomain>::new("ThreadOwner")
        .subjects(|member| member.is_owner)
        .build();
    let collaborator_policy: Arc<dyn Policy<ThreadDomain>> = Arc::from(
        PolicyBuilder::<ThreadDomain>::new("Collaborator")
            .subjects(|member| member.is_collaborator)
            .build(),
    );
    // The block rule for the scoped case *grants when it matches* so that
    // `NotPolicy` can invert it into a local gate. Compare with the
    // checker-level rules above, where `Effect::Forbid` keeps natural
    // polarity — this inversion is the price of scoping, which is why a
    // global block should prefer `Effect::Forbid`.
    let muted = PolicyBuilder::<ThreadDomain>::new("Muted")
        .subjects(|member| member.muted)
        .build();

    let collaborator_unless_muted = AndPolicy::try_new(vec![
        collaborator_policy,
        Arc::new(NotPolicy::new(muted)) as Arc<dyn Policy<ThreadDomain>>,
    ])
    .expect("gate has the grant arm and the guard");

    let mut checker = PermissionChecker::<ThreadDomain>::named("ThreadChecker");
    checker.add_policy(owner_policy);
    checker.add_policy(collaborator_unless_muted);

    let muted_collaborator = Member {
        is_owner: false,
        is_collaborator: true,
        muted: true,
    };
    let muted_owner = Member {
        is_owner: true,
        is_collaborator: false,
        muted: true,
    };

    let session = EvaluationSession::empty();
    let action = Access;
    let context = ();

    // The mute only gates the collaborator path...
    checker
        .bind(&session, &muted_collaborator, &action, &context)
        .check(&Thread)
        .await
        .assert_denied();
    // ...the owner path is untouched, which a global Effect::Forbid mute
    // could not express.
    checker
        .bind(&session, &muted_owner, &action, &context)
        .check(&Thread)
        .await
        .assert_granted_by("ThreadOwner");

    println!("\nScoped exclusion: muted collaborator blocked, muted owner unaffected.");
}

Trait Implementations

impl<D: PolicyDomain> Policy<D> for NotPolicy<D>

fn policy_type(&self) -> Cow<'static, str>

Policy name for debugging, trace trees, and telemetry fallbacks.

fn effect(&self) -> Effect

The declared effect of this policy. Defaults to Effect::Allow.

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EvalCtx<'life2, D>, ) -> Pin<Box<dyn Future<Output = PolicyEvalResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Evaluates whether access should be granted.

fn evaluate_batch<'item, 'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 BatchEvalCtx<'item, D>, ) -> Pin<Box<dyn Future<Output = Vec<PolicyEvalResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'item: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Evaluates access for a batch of resources.

fn security_rule(&self) -> SecurityRuleMetadata

Metadata describing the security rule that backs this policy.