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> ) -> Result<Self, EntityAttrEvaluationError>

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 new_no_attrs(uid: EntityUid, parents: HashSet<EntityUid>) -> Self

Create a new Entity with no attributes.

Unlike Entity::new(), this constructor cannot error. (The only source of errors in Entity::new() are attributes.)

pub fn with_uid(uid: EntityUid) -> Self

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

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, impl Diagnostic>>

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

This can also return Some(Err) if the attribute is not a value (i.e., is unknown due to partial evaluation).

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()).unwrap();
assert_eq!(entity.attr("age").unwrap().unwrap(), EvalResult::Long(21));
assert_eq!(entity.attr("department").unwrap().unwrap(), EvalResult::String("CS".to_string()));
assert!(entity.attr("foo").is_none());

pub fn into_inner( self ) -> (EntityUid, HashMap<String, RestrictedExpression>, HashSet<EntityUid>)

Consume the entity and return the entity’s owned Uid, attributes and parents.

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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