Struct Entities 

pub struct Entities { /* private fields */ }

Represents an entity hierarchy, and allows looking up Entity objects by UID. Note that Entities is not Serialize itself – use either the from_json_*() and write_to_json() methods here, or the proto module in cedar-policy, which is capable of ser/de both Core types like this and cedar-policy types.

Implementations

impl Entities

pub fn new() -> Self

Create a fresh Entities with no entities

pub fn is_partial(&self) -> bool

Is this a partial store (created with .partial())

pub fn entity(&self, uid: &EntityUID) -> Dereference<'_, Entity>

Get the Entity with the given UID, if any

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

Iterate over the Entitys in the Entities

pub fn deep_eq(&self, other: &Self) -> bool

Test if two entity hierarchies are structurally equal. The hierarchies must contain the same set of entity ids, and the entities with each id must be structurally equal (decided by Entity::deep_eq). Ancestor equality between entities is always decided by comparing the transitive closure of ancestor and not direct parents.

pub fn add_entities( self, collection: impl IntoIterator<Item = Arc<Entity>>, schema: Option<&impl Schema>, tc_computation: TCComputation, extensions: &Extensions<'_>, ) -> Result<Self>

Adds the crate::ast::Entitys in the iterator to this Entities. Fails if

• there is a pair of non-identical entities in the passed iterator with the same Entity UID, or
• there is an entity in the passed iterator with the same Entity UID as a non-identical entity in this structure, or
• any error is encountered in the transitive closure computation.

If schema is present, then the added entities will be validated against the schema, returning an error if they do not conform to the schema. (This method will not add action entities from the schema.)

If you pass TCComputation::AssumeAlreadyComputed, then the caller is responsible for ensuring that TC and DAG hold before calling this method.

pub fn remove_entities( self, collection: impl IntoIterator<Item = EntityUID>, tc_computation: TCComputation, ) -> Result<Self>

Removes the crate::ast::EntityUIDs in the interator from this Entities Fails if any error is encountered in the transitive closure computation.

If you pass TCComputation::AssumeAlreadyComputed, then the caller is responsible for ensuring that TC and DAG hold before calling this method

pub fn upsert_entities( self, collection: impl IntoIterator<Item = Arc<Entity>>, schema: Option<&impl Schema>, tc_computation: TCComputation, extensions: &Extensions<'_>, ) -> Result<Self>

Adds the crate::ast::Entitys in the iterator to this Entities. Fails if any error is encountered in the transitive closure computation.

When a duplicate is encountered, the value is overwritten by the latest version.

If schema is present, then the added entities will be validated against the schema, returning an error if they do not conform to the schema. (This method will not add action entities from the schema.)

If you pass TCComputation::AssumeAlreadyComputed, then the caller is responsible for ensuring that TC and DAG hold before calling this method.

pub fn from_entities( entities: impl IntoIterator<Item = Entity>, schema: Option<&impl Schema>, tc_computation: TCComputation, extensions: &Extensions<'_>, ) -> Result<Self>

Create an Entities object with the given entities.

If schema is present, then action entities from that schema will also be added to the Entities. Also, the entities in entities will be validated against the schema, returning an error if they do not conform to the schema.

If you pass TCComputation::AssumeAlreadyComputed, then the caller is responsible for ensuring that TC and DAG hold before calling this method.

Errors

• EntitiesError::Duplicate if there is a pair of non-identical entities in entities with the same Entity UID, or there is an entity in entities with the same Entity UID as a non-identical entity in this structure
• EntitiesError::TransitiveClosureError if tc_computation == TCComputation::EnforceAlreadyComputed and the entities are not transitively closed
• EntitiesError::InvalidEntity if schema is not none and any entities do not conform to the schema

pub fn len(&self) -> usize

Returns the length of the Entities object

pub fn is_empty(&self) -> bool

Returns true if the Entities object is empty

pub fn to_json_value(&self) -> Result<Value>

Convert an Entities object into a JSON value suitable for parsing in via EntityJsonParser.

The returned JSON value will be parse-able even with no Schema.

To parse an Entities object from a JSON value, use EntityJsonParser.

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

Dump an Entities object into an entities JSON file.

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

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

pub fn to_dot_str(&self, f: &mut impl Write) -> Result

Write entities into a DOT graph. This function only returns an Err result on a failing write! to f, so it is infallible if the Write implementation cannot fail (e.g., String).

Trait Implementations

impl Clone for Entities

fn clone(&self) -> Entities

Returns a duplicate 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 Display for Entities

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

Formats the value using the given formatter.

impl IntoIterator for Entities

type Item = Entity

The type of the elements being iterated over.

type IntoIter = Map<IntoValues<EntityUID, Arc<Entity>>, fn(Arc<Entity>) -> Entity>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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 Eq for Entities

impl StructuralPartialEq for Entities