Struct PermissionCollisionChecker 

pub struct PermissionCollisionChecker { /* private fields */ }

Low-level permission collision checker for runtime validation and analysis.

This checker validates permission strings for duplicates and hash collisions, providing detailed reports about any issues found. Unlike the compile-time validation, this can handle dynamic permission strings.

Use Cases

• Runtime validation: When permissions change during application lifecycle
• Debugging and analysis: Need to inspect collision maps and conflicts
• Custom validation workflows: Require fine-grained control over validation process
• Performance-critical paths: Direct validation without builder overhead

Compared to ApplicationValidator

• State: Stateful - maintains collision map for post-validation analysis
• Usage: Direct instantiation with complete permission set
• Methods: Provides introspection methods like get_conflicting_permissions()
• Lifecycle: Can be reused after validation for analysis

For simple application startup validation, consider using ApplicationValidator which provides a more ergonomic builder pattern API.

See Also

• ApplicationValidator - High-level builder pattern validator for startup validation

Examples

Basic validation with post-analysis

use axum_gate::permissions::PermissionCollisionChecker;

let permissions = vec![
    "user:read".to_string(),
    "user:write".to_string(),
    "admin:full_access".to_string(),
];

let mut checker = PermissionCollisionChecker::new(permissions);
let report = checker.validate()?;

if report.is_valid() {
    println!("All permissions are valid!");
    // Can still use checker for analysis after validation
    println!("Total permissions: {}", checker.permission_count());
    println!("Unique IDs: {}", checker.unique_id_count());
} else {
    println!("Issues found: {}", report.summary());
    // Check for specific conflicts
    let conflicts = checker.get_conflicting_permissions("user:read");
    if !conflicts.is_empty() {
        println!("Conflicts with user:read: {:?}", conflicts);
    }
}

Runtime permission updates

use axum_gate::permissions::PermissionCollisionChecker;

fn update_permissions(new_permissions: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {
    let mut checker = PermissionCollisionChecker::new(new_permissions);
    let report = checker.validate()?;

    if !report.is_valid() {
        // Can analyze specific issues
        for collision in &report.collisions {
            println!("Hash ID {} has conflicts: {:?}", collision.id, collision.permissions);
        }
        return Err("Permission validation failed".into());
    }

    // Validation passed - can still inspect the checker
    let summary = checker.get_permission_summary();
    println!("Permission distribution: {:?}", summary);
    Ok(())
}

Implementations

impl PermissionCollisionChecker

pub fn new(permissions: Vec<String>) -> Self

Creates a new collision checker with the given permission strings.

Arguments

• permissions - Vector of permission strings to validate

pub fn validate(&mut self) -> Result<ValidationReport>

Validates all permissions for uniqueness and collision-free hashing.

This method performs comprehensive validation including:

• Duplicate string detection
• Hash collision detection
• Internal collision map building

Returns

• Ok(ValidationReport) - Detailed report of validation results
• Err(axum_gate::errors::Error) - If validation process itself fails

Examples

use axum_gate::permissions::PermissionCollisionChecker;

let permissions = vec!["read:file".to_string(), "write:file".to_string()];
let mut checker = PermissionCollisionChecker::new(permissions);

match checker.validate() {
    Ok(report) => {
        if report.is_valid() {
            println!("Validation passed!");
        } else {
            eprintln!("Validation failed: {}", report.summary());
        }
    }
    Err(e) => eprintln!("Validation error: {}", e),
}

pub fn get_conflicting_permissions(&self, permission: &str) -> Vec<String>

Returns permissions that hash to the same ID as the given permission.

This method is useful for debugging collision issues or understanding how permissions map to hash IDs.

Arguments

• permission - The permission string to check for conflicts

Returns

Vector of permission strings that conflict with the given permission. The returned vector will not include the input permission itself.

pub fn get_permission_summary(&self) -> HashMap<u64, Vec<String>>

Returns a summary of all permissions grouped by their hash ID.

This method provides a complete view of how permissions are distributed across hash IDs, which can be useful for analysis and debugging.

Returns

HashMap where keys are hash IDs and values are vectors of permission strings that hash to that ID.

pub fn permission_count(&self) -> usize

Returns the total number of permissions being validated.

pub fn unique_id_count(&self) -> usize

Returns the number of unique hash IDs generated from the permissions.