Struct Permissions 

pub struct Permissions { /* private fields */ }

A collection of permissions with efficient storage and fast operations.

Uses compressed bitmap storage internally for optimal memory usage and O(1) permission checks. Designed for high-performance authorization systems that need to handle thousands of permissions per user efficiently.

Examples

use axum_gate::permissions::Permissions;

// Create and populate permissions
let mut permissions = Permissions::new();
permissions
    .grant("read:profile")
    .grant("write:profile")
    .grant("delete:profile");

// Check individual permissions
assert!(permissions.has("read:profile"));
assert!(!permissions.has("admin:users"));

// Check multiple permissions
assert!(permissions.has_all(["read:profile", "write:profile"]));
assert!(permissions.has_any(["read:profile", "admin:users"]));

Builder Pattern

use axum_gate::permissions::Permissions;

let permissions = Permissions::new()
    .with("read:api")
    .with("write:api")
    .build();

Implementations

impl Permissions

pub fn new() -> Self

Creates a new empty permission set.

Examples

use axum_gate::permissions::Permissions;

let permissions = Permissions::new();
assert!(permissions.is_empty());

pub fn grant<P>(&mut self, permission: P) -> &mut Self

where P: Into<PermissionId>,

Grants a permission to this permission set.

Returns a mutable reference to self for method chaining.

Examples

use axum_gate::permissions::{Permissions, PermissionId};

let mut permissions = Permissions::new();
permissions
    .grant("read:profile")
    .grant(PermissionId::from("write:profile"));

assert!(permissions.has("read:profile"));
assert!(permissions.has(PermissionId::from("write:profile")));

pub fn revoke<P>(&mut self, permission: P) -> &mut Self

where P: Into<PermissionId>,

Revokes a permission from this permission set.

Returns a mutable reference to self for method chaining.

Examples

use axum_gate::permissions::{Permissions, PermissionId};

let mut permissions: Permissions = ["read:profile", "write:profile"].into_iter().collect();
permissions.revoke(PermissionId::from("write:profile"));

assert!(permissions.has("read:profile"));
assert!(!permissions.has("write:profile"));

pub fn has<P>(&self, permission: P) -> bool

where P: Into<PermissionId>,

Checks if a specific permission is granted.

Examples

use axum_gate::permissions::{Permissions, PermissionId};

let permissions: Permissions = ["read:profile"].into_iter().collect();

assert!(permissions.has("read:profile"));
assert!(permissions.has(PermissionId::from("read:profile")));
assert!(!permissions.has("write:profile"));

pub fn has_all<I, P>(&self, permissions: I) -> bool

where I: IntoIterator<Item = P>, P: Into<PermissionId>,

Checks if all of the specified permissions are granted.

Examples

use axum_gate::permissions::{Permissions, PermissionId};

let permissions: Permissions = [
    "read:profile",
    "write:profile",
    "read:posts",
].into_iter().collect();

assert!(permissions.has_all(["read:profile", "write:profile"]));
assert!(permissions.has_all([PermissionId::from("read:profile")]));
assert!(!permissions.has_all(["read:profile", "admin:users"]));

pub fn has_any<I, P>(&self, permissions: I) -> bool

where I: IntoIterator<Item = P>, P: Into<PermissionId>,

Checks if any of the specified permissions are granted.

Examples

use axum_gate::permissions::{Permissions, PermissionId};

let permissions: Permissions = ["read:profile"].into_iter().collect();

assert!(permissions.has_any(["read:profile", "write:profile"]));
assert!(permissions.has_any([PermissionId::from("read:profile")]));
assert!(!permissions.has_any(["write:profile", "admin:users"]));

pub fn len(&self) -> usize

Returns the number of permissions in this set.

Examples

use axum_gate::permissions::Permissions;

let permissions: Permissions = ["read:profile", "write:profile"].into_iter().collect();
assert_eq!(permissions.len(), 2);

pub fn is_empty(&self) -> bool

Returns true if the permission set contains no permissions.

Examples

use axum_gate::permissions::Permissions;

let permissions = Permissions::new();
assert!(permissions.is_empty());

let mut permissions = Permissions::new();
permissions.grant("read:profile");
assert!(!permissions.is_empty());

pub fn clear(&mut self)

Removes all permissions from this set.

Examples

use axum_gate::permissions::Permissions;

let mut permissions: Permissions = ["read:profile", "write:profile"].into_iter().collect();
assert!(!permissions.is_empty());

permissions.clear();
assert!(permissions.is_empty());

pub fn union(&mut self, other: &Permissions) -> &mut Self

Computes the union of this permission set with another.

This grants all permissions that exist in either set.

Examples

use axum_gate::permissions::Permissions;

let mut permissions1: Permissions = ["read:profile"].into_iter().collect();
let permissions2: Permissions = ["write:profile"].into_iter().collect();

permissions1.union(&permissions2);

assert!(permissions1.has("read:profile"));
assert!(permissions1.has("write:profile"));

pub fn intersection(&mut self, other: &Permissions) -> &mut Self

Computes the intersection of this permission set with another.

This keeps only permissions that exist in both sets.

Examples

use axum_gate::permissions::Permissions;

let mut permissions1: Permissions = ["read:profile", "write:profile"].into_iter().collect();
let permissions2: Permissions = ["read:profile", "admin:users"].into_iter().collect();

permissions1.intersection(&permissions2);

assert!(permissions1.has("read:profile"));
assert!(!permissions1.has("write:profile"));
assert!(!permissions1.has("admin:users"));

pub fn difference(&mut self, other: &Permissions) -> &mut Self

Computes the difference of this permission set with another.

This removes all permissions that exist in the other set.

Examples

use axum_gate::permissions::Permissions;

let mut permissions1: Permissions = ["read:profile", "write:profile"].into_iter().collect();
let permissions2: Permissions = ["write:profile"].into_iter().collect();

permissions1.difference(&permissions2);

assert!(permissions1.has("read:profile"));
assert!(!permissions1.has("write:profile"));

pub fn with<P>(self, permission: P) -> Self

where P: Into<PermissionId>,

Builder method for granting a permission (immutable version).

Use this when building permissions in a functional style or when you need to create permissions without mutable access. Prefer grant() for performance-critical code where you’re modifying existing permission sets.

Examples

use axum_gate::permissions::{Permissions, PermissionId};

let permissions = Permissions::new()
    .with("read:profile")
    .with(PermissionId::from("write:profile"))
    .build();

assert!(permissions.has("read:profile"));
assert!(permissions.has("write:profile"));

pub fn build(self) -> Self

Finalizes the builder pattern.

This method returns self unchanged, providing a clean conclusion to the builder pattern. Use this when you want to clearly signal the end of permission configuration.

Examples

use axum_gate::permissions::Permissions;

let permissions = Permissions::new()
    .with("read:profile")
    .with("write:profile")
    .build();

pub fn iter(&self) -> impl Iterator<Item = u64> + '_

Returns an iterator over the permission IDs in this collection.

Use this when you need to examine all granted permissions or integrate with external systems that work with permission IDs directly.

Examples

use axum_gate::permissions::Permissions;

let permissions: Permissions = ["read:profile", "write:profile"].into_iter().collect();
let ids: Vec<u64> = permissions.iter().collect();
assert_eq!(ids.len(), 2);

Trait Implementations

impl AsRef<RoaringTreemap> for Permissions

fn as_ref(&self) -> &RoaringTreemap

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Permissions

fn clone(&self) -> Permissions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Permissions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Permissions

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Permissions

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Permissions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Permissions> for RoaringTreemap

fn from(permissions: Permissions) -> Self

Converts to this type from the input type.

impl From<RoaringTreemap> for Permissions

fn from(bitmap: RoaringTreemap) -> Self

Converts to this type from the input type.

impl<P> FromIterator<P> for Permissions

where P: Into<PermissionId>,

fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> Self

Creates a permission set from an iterator of permission names.

Examples

use axum_gate::permissions::Permissions;

let permissions: Permissions = ["read:profile", "write:profile", "read:posts"]
    .into_iter()
    .collect();

assert!(permissions.has("read:profile"));
assert!(permissions.has("write:profile"));
assert!(permissions.has("read:posts"));

impl PartialEq for Permissions

fn eq(&self, other: &Permissions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Permissions

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Permissions