Struct 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 (and no tags).

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 or tags.

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

pub fn new_with_tags( uid: EntityUid, attrs: impl IntoIterator<Item = (String, RestrictedExpression)>, parents: impl IntoIterator<Item = EntityUid>, tags: impl IntoIterator<Item = (String, RestrictedExpression)>, ) -> Result<Self, EntityAttrEvaluationError>

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

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

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 deep_eq(&self, other: &Self) -> bool

Test if two entities are structurally equal. That is, not only do they have the same UID, but they also have the same attributes and ancestors.

Note that ancestor equality is determined by examining the ancestors entities provided when constructing these objects, without computing their transitive closure. For accurate comparison, entities should be constructed with the transitive closure precomputed or be drawn from an Entities object which will perform this computation.

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, PartialValueToValueError>>

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 tag( &self, tag: &str, ) -> Option<Result<EvalResult, PartialValueToValueError>>

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

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

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

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

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

Parse an entity from an in-memory JSON value If a schema is provided, it is handled identically to Entities::from_json_str

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

Parse an entity from a JSON string If a schema is provided, it is handled identically to Entities::from_json_str

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

Parse an entity from a JSON reader If a schema is provided, it is handled identically to Entities::from_json_str

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

Dump an Entity object into an entity 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 Entity object from JSON , use Self::from_json_file, Self::from_json_value, or Self::from_json_str.

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

Dump an Entity object into an in-memory JSON object.

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

To read an Entity object from JSON , use Self::from_json_file, Self::from_json_value, or Self::from_json_str.

pub fn to_json_string(&self) -> Result<String, EntitiesError>

Dump an Entity object into a JSON string.

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

To read an Entity object from JSON , use Self::from_json_file, Self::from_json_value, or Self::from_json_str.

Trait Implementations

impl Clone for Entity

fn clone(&self) -> Entity

Returns a duplicate 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 From<&Entity> for Entity

Available on crate feature protobufs only.

fn from(v: &Entity) -> Entity

Converts to this type from the input type.

impl From<&Entity> for Entity

Available on crate feature protobufs only.

fn from(v: &Entity) -> Entity

Converts to this type from the input type.

impl Hash for Entity

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 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 Protobuf for Entity

Available on crate feature protobufs only.

fn encode(&self) -> Vec<u8>

Encode into protobuf format. Returns a freshly-allocated buffer containing binary data.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

Decode the binary data in buf, producing something of type Self

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