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.

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