Enum AuthorizationExpression

pub enum AuthorizationExpression {
    ConjunctionOf(Vec<AuthorizationExpression>),
    DisjunctionOf(Vec<AuthorizationExpression>),
    AccessToken(String),
    Nil,
}

Variants

ConjunctionOf(Vec<AuthorizationExpression>)

A conjunction of multiple access tokens or scopes.

DisjunctionOf(Vec<AuthorizationExpression>)

A disjunction of multiple access tokens or scopes.

AccessToken(String)

An access token.

Nil

A nil expression (empty string).

Implementations

impl AuthorizationExpression

pub fn from_json(json: &Value) -> Result<Self, String>

Create a new AuthorizationExpression from a JSON value.

Arguments

json - The JSON value to parse.

Returns

A new AuthorizationExpression instance.

Example

use accumulo_access::AuthorizationExpression;
let json = serde_json::json!({
  "and": [
   "A",
  {
    "or": [
      "B",
     "C"
   ]
 }
]
});
let expr = AuthorizationExpression::from_json(&json).unwrap();

pub fn evaluate(&self, authorizations: &HashSet<String>) -> bool

Evaluate the expression with the given set of authorizations. Returns true if the authorizations are valid, false otherwise.

Arguments

authorizations - The set of authorizations to check.

Example

use std::collections::HashSet;
use accumulo_access::AuthorizationExpression;
let expr = AuthorizationExpression::ConjunctionOf(vec![
   AuthorizationExpression::AccessToken("A".to_string()),
  AuthorizationExpression::DisjunctionOf(vec![
     AuthorizationExpression::AccessToken("B".to_string()),
    AuthorizationExpression::AccessToken("C".to_string()),
]),
]);
let authorizations = HashSet::from([
   "A".to_string(),
  "B".to_string(),
]);
assert_eq!(expr.evaluate(&authorizations), true);

pub fn to_json(&self) -> Value

Create a JSON representation of the expression tree.

Returns

A JSON value representing the expression tree.

Example

use accumulo_access::AuthorizationExpression;
let expr = AuthorizationExpression::ConjunctionOf(vec![
  AuthorizationExpression::AccessToken("A".to_string()),
 AuthorizationExpression::AccessToken("B".to_string()),
]);
let json = expr.to_json();
assert_eq!(json, serde_json::json!({"and": ["A", "B"]}));

pub fn to_json_str(&self) -> String

Create a JSON string representation of the expression tree.

Returns

A JSON string representing the expression tree.

Example

use accumulo_access::AuthorizationExpression;
let expr = AuthorizationExpression::ConjunctionOf(vec![
 AuthorizationExpression::AccessToken("A".to_string()),
 AuthorizationExpression::AccessToken("B".to_string()),
]);
 
let json_str = expr.to_json_str();
assert_eq!(json_str, "{\"and\":[\"A\",\"B\"]}");

pub fn to_expression_str(&self) -> String

Create a string representation of the expression tree.

Returns

A string representing the expression tree.

Example

use accumulo_access::AuthorizationExpression;
let expr1 = AuthorizationExpression::ConjunctionOf(vec![
AuthorizationExpression::AccessToken("A".to_string()),
AuthorizationExpression::AccessToken("B".to_string()),
]);
 
let expr_str = expr1.to_expression_str();
assert_eq!(expr_str, "A&B");    ///

let expr2 = AuthorizationExpression::DisjunctionOf(vec![
AuthorizationExpression::AccessToken("A".to_string()),
AuthorizationExpression::AccessToken("B".to_string()),
]);

let expr_str = expr2.to_expression_str();
assert_eq!(expr_str, "A|B");

pub fn normalize(&mut self)

Normalize the expression tree by sorting and deduplicating the nodes.

Example

use accumulo_access::AuthorizationExpression;
let mut expr = AuthorizationExpression::ConjunctionOf(vec![
AuthorizationExpression::AccessToken("B".to_string()),
AuthorizationExpression::AccessToken("A".to_string()),
AuthorizationExpression::AccessToken("B".to_string()),
AuthorizationExpression::DisjunctionOf(vec![
AuthorizationExpression::AccessToken("C".to_string()),
AuthorizationExpression::AccessToken("D".to_string()),
AuthorizationExpression::AccessToken("D".to_string())]
)]);
expr.normalize();
let expected = AuthorizationExpression::ConjunctionOf(vec![
AuthorizationExpression::AccessToken("A".to_string()),
AuthorizationExpression::AccessToken("B".to_string()),
AuthorizationExpression::DisjunctionOf(vec![
AuthorizationExpression::AccessToken("C".to_string()),
AuthorizationExpression::AccessToken("D".to_string())]
)]);
 
assert_eq!(expr, expected);

Trait Implementations

impl Clone for AuthorizationExpression

fn clone(&self) -> AuthorizationExpression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AuthorizationExpression

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

Formats the value using the given formatter.

impl Display for AuthorizationExpression

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

Formats the value using the given formatter.

impl Hash for AuthorizationExpression

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for AuthorizationExpression

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for AuthorizationExpression

fn eq(&self, other: &Self) -> 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 PartialOrd for AuthorizationExpression

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for AuthorizationExpression