Struct cedar_policy::Entity

pub struct Entity(/* private fields */);

Entity datatype

Implementations

impl Entity

pub fn new( uid: EntityUid, attrs: HashMap<String, RestrictedExpression>, parents: HashSet<EntityUid>, ) -> Self

Create a new Entity with this Uid, attributes, and parents.

Attribute values are specified here as “restricted expressions”. See docs on RestrictedExpression

let eid = EntityId::from_str("alice").unwrap();
let type_name = EntityTypeName::from_str("User").unwrap();
let euid = EntityUid::from_type_name_and_id(type_name, eid);
let attrs = HashMap::from([
    ("age".to_string(), RestrictedExpression::from_str("21").unwrap()),
    ("department".to_string(), RestrictedExpression::from_str("\"CS\"").unwrap()),
]);
let parent_eid = EntityId::from_str("admin").unwrap();
let parent_type_name = EntityTypeName::from_str("Group").unwrap();
let parent_euid = EntityUid::from_type_name_and_id(parent_type_name, parent_eid);
let parents = HashSet::from([parent_euid]);
let entity = Entity::new(euid, attrs, parents);

pub fn with_uid(uid: EntityUid) -> Self

Create a new Entity with this Uid, no attributes, and no parents.

use cedar_policy::{Entity, EntityId, EntityTypeName, EntityUid};
let eid = EntityId::from_str("alice").unwrap();
let type_name = EntityTypeName::from_str("User").unwrap();
let euid = EntityUid::from_type_name_and_id(type_name, eid);
let alice = Entity::with_uid(euid);

pub fn uid(&self) -> EntityUid

Get the Uid of this entity

let type_name = EntityTypeName::from_str("User").unwrap();
let euid = EntityUid::from_type_name_and_id(type_name, eid);
let alice = Entity::with_uid(euid.clone());
assert_eq!(alice.uid(), euid);

pub fn attr(&self, attr: &str) -> Option<Result<EvalResult, EvaluationError>>

Get the value for the given attribute, or None if not present.

This can also return Some(Err) if the attribute had an illegal value.

use cedar_policy::{Entity, EntityId, EntityTypeName, EntityUid, EvalResult,
    RestrictedExpression};
use std::collections::{HashMap, HashSet};
use std::str::FromStr;
let eid = EntityId::from_str("alice").unwrap();
let type_name = EntityTypeName::from_str("User").unwrap();
let euid = EntityUid::from_type_name_and_id(type_name, eid);
let attrs = HashMap::from([
    ("age".to_string(), RestrictedExpression::from_str("21").unwrap()),
    ("department".to_string(), RestrictedExpression::from_str("\"CS\"").unwrap()),
]);
let entity = Entity::new(euid, attrs, HashSet::new());
assert_eq!(entity.attr("age").unwrap(), Ok(EvalResult::Long(21)));
assert_eq!(entity.attr("department").unwrap(), Ok(EvalResult::String("CS".to_string())));

Trait Implementations

impl Clone for Entity

fn clone(&self) -> Entity

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Entity

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

Formats the value using the given formatter.

impl Display for Entity

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

Formats the value using the given formatter.

impl PartialEq for Entity

fn eq(&self, other: &Entity) -> 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 RefCast for Entity

type From = Entity

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self

impl Eq for Entity

impl StructuralPartialEq for Entity