Struct cedar_policy::Entities

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

Represents an entity hierarchy, and allows looking up Entity objects by Uid.

Implementations

impl Entities

pub fn empty() -> Self

Create a fresh Entities with no entities

use cedar_policy::Entities;
let entities = Entities::empty();

pub fn get(&self, uid: &EntityUid) -> Option<&Entity>

Get the Entity with the given Uid, if any

pub fn iter(&self) -> impl Iterator<Item = &Entity>

Iterate over the Entity’s in the Entities

pub fn from_entities( entities: impl IntoIterator<Item = Entity>, ) -> Result<Self, EntitiesError>

Create an Entities object with the given entities. It will error if the entities cannot be read or if the entities hierarchy is cyclic

pub fn from_json_str( json: &str, schema: Option<&Schema>, ) -> Result<Self, EntitiesError>

Parse an entities JSON file (in &str form) into an Entities object

If a schema is provided, this will inform the parsing: for instance, it will allow __entity and __extn escapes to be implicit, and it will error if attributes have the wrong types (e.g., string instead of integer).

use std::collections::HashMap;
use std::str::FromStr;
let data =r#"
[
{
  "uid": {"type":"User","id":"alice"},
  "attrs": {
    "age":19,
    "ip_addr":{"__extn":{"fn":"ip", "arg":"10.0.1.101"}}
  },
  "parents": [{"type":"Group","id":"admin"}]
},
{
  "uid": {"type":"Groupd","id":"admin"},
  "attrs": {},
  "parents": []
}
]
"#;
let entities = Entities::from_json_str(data, None).unwrap();
let eid = EntityId::from_str("alice").unwrap();
let type_name: EntityTypeName = EntityTypeName::from_str("User").unwrap();
let euid = EntityUid::from_type_name_and_id(type_name, eid);
let entity = entities.get(&euid).unwrap();
assert_eq!(entity.attr("age").unwrap(), Ok(EvalResult::Long(19)));
let ip = entity.attr("ip_addr").unwrap().unwrap();
assert_eq!(ip, EvalResult::ExtensionValue("10.0.1.101/32".to_string()));

pub fn from_json_value( json: Value, schema: Option<&Schema>, ) -> Result<Self, EntitiesError>

Parse an entities JSON file (in serde_json::Value form) into an Entities object

If a schema is provided, this will inform the parsing: for instance, it will allow __entity and __extn escapes to be implicit, and it will error if attributes have the wrong types (e.g., string instead of integer).

use std::collections::HashMap;
use std::str::FromStr;
let data =serde_json::json!(
[
{
  "uid": {"type":"User","id":"alice"},
  "attrs": {
    "age":19,
    "ip_addr":{"__extn":{"fn":"ip", "arg":"10.0.1.101"}}
  },
  "parents": [{"type":"Group","id":"admin"}]
},
{
  "uid": {"type":"Groupd","id":"admin"},
  "attrs": {},
  "parents": []
}
]
);
let entities = Entities::from_json_value(data, None).unwrap();

pub fn from_json_file( json: impl Read, schema: Option<&Schema>, ) -> Result<Self, EntitiesError>

Parse an entities JSON file (in std::io::Read form) into an Entities object

If a schema is provided, this will inform the parsing: for instance, it will allow __entity and __extn escapes to be implicit, and it will error if attributes have the wrong types (e.g., string instead of integer).

pub fn is_ancestor_of(&self, a: &EntityUid, b: &EntityUid) -> bool

Is entity a an ancestor of entity b? Same semantics as b in a in the Cedar language

pub fn ancestors<'a>( &'a self, euid: &EntityUid, ) -> Option<impl Iterator<Item = &'a EntityUid>>

Get an iterator over the ancestors of the given Euid. Returns None if the given Euid does not exist.

pub fn write_to_json(&self, f: impl Write) -> Result<(), EntitiesError>

Dump an Entities object into an entities JSON file.

The resulting JSON will be suitable for parsing in via from_json_*, and will be parse-able even with no Schema.

To read an Entities object from an entities JSON file, use from_json_file.

Trait Implementations

impl Clone for Entities

fn clone(&self) -> Entities

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Entities

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

Formats the value using the given formatter.

impl Default for Entities

fn default() -> Entities

Returns the “default value” for a type.

impl PartialEq for Entities

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

type From = Entities

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

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

impl Eq for Entities

impl StructuralPartialEq for Entities