Struct EntityUid

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

Unique id for an entity, such as User::"alice".

An EntityUid contains an EntityTypeName and EntityId. It can be constructed from these components using EntityUid::from_type_name_and_id, parsed from a string using .parse() (via EntityUid::from_str), or constructed from a JSON value using EntityUid::from_json.

Implementations

impl EntityUid

pub fn type_name(&self) -> &EntityTypeName

Returns the portion of the Euid that represents namespace and entity type

let json_data = serde_json::json!({ "__entity": { "type": "User", "id": "alice" } });
let euid = EntityUid::from_json(json_data).unwrap();
assert_eq!(euid.type_name(), &EntityTypeName::from_str("User").unwrap());

pub fn id(&self) -> &EntityId

Returns the id portion of the Euid

let json_data = serde_json::json!({ "__entity": { "type": "User", "id": "alice" } });
let euid = EntityUid::from_json(json_data).unwrap();
assert_eq!(euid.id(), &EntityId::from_str("alice").unwrap());

pub fn from_type_name_and_id(name: EntityTypeName, id: EntityId) -> Self

Creates EntityUid from EntityTypeName and EntityId

 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);

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

Creates EntityUid from a JSON value, which should have either the implicit or explicit __entity form.

let json_data = serde_json::json!({ "__entity": { "type": "User", "id": "123abc" } });
let euid = EntityUid::from_json(json_data).unwrap();

Trait Implementations

impl Clone for EntityUid

fn clone(&self) -> EntityUid

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EntityUid

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

Formats the value using the given formatter.

impl Display for EntityUid

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

Formats the value using the given formatter.

impl FromStr for EntityUid

fn from_str(uid_str: &str) -> Result<Self, Self::Err>

Parse an EntityUid.

An EntityUid consists of an EntityTypeName followed by a quoted EntityId. The two are joined by a ::. For the formal grammar, see https://docs.cedarpolicy.com/policies/syntax-grammar.html#entity

Examples:

 let euid: EntityUid = r#"Foo::Bar::"george""#.parse().unwrap();
 // Get the type of this euid (`Foo::Bar`)
 euid.type_name();
 // Or the id
 euid.id();

This FromStr implementation requires the normalized representation of the UID. See https://github.com/cedar-policy/rfcs/pull/9/.

A note on safety:

DO NOT create EntityUid’s via string concatenation. If you have separate components of an EntityUid, use EntityUid::from_type_name_and_id

type Err = ParseErrors

The associated error which can be returned from parsing.

impl Hash for EntityUid

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 EntityUid

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

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

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

type From = EntityUID

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

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

impl Eq for EntityUid

impl StructuralPartialEq for EntityUid