Struct entity::UntypedEnt

pub struct UntypedEnt { /* fields omitted */ }

Represents a general-purpose ent that is shapeless (no hard type) and maintains fields and edges using internal maps. This ent can optionally be connected to a database and supports additional functionality like loading ents from edges when connected.

Implementations

impl UntypedEnt

pub fn new(
    id: Id,
    fields: HashMap<String, Field>,
    edges: HashMap<String, Edge>
) -> Self

Creates a new ent using the given id, field map, and edge map

pub fn empty_with_id(id: Id) -> Self

Creates an empty ent with the provided id

pub fn from_collections<FI: IntoIterator<Item = Field>, EI: IntoIterator<Item = Edge>>(
    id: Id,
    field_collection: FI,
    edge_collection: EI
) -> Self

Creates a map ent with the provided id, fields from the given collection, and edges from the other given collection

pub fn update_field<N: Into<String>, V: Into<Value>>(
    &mut self,
    into_name: N,
    into_value: V
) -> Result<Value, EntMutationError>

Replaces the ent's local field's value with the given value, returning the old previous value if the field exists

If the field does not exist, does NOT insert the value as a new field

pub fn add_ents_to_edge<N: Into<String>, I: IntoIterator<Item = Id>>(
    &mut self,
    name: N,
    ids: I
) -> Result<(), EntMutationError>

Updates the ent's local edge's list to contain the provided ids

If there are too many ids (in the case of >1 for MaybeOne/One), this method will fail.

pub fn remove_ents_from_edge<N: Into<String>, I: IntoIterator<Item = Id>>(
    &mut self,
    name: N,
    ids: I
) -> Result<(), EntMutationError>

Updates the ent's local edge's list to remove the provided ids

If this would result in an invalid edge (One being empty), this method will fail.

pub fn remove_ents_from_all_edges<I: IntoIterator<Item = Id>>(
    &mut self,
    ids: I
) -> Result<(), EntMutationError>

Updates all of the ent's local edges to remove the provided ids

If this would result in an invalid edge (One being empty), this method will fail.

Trait Implementations

impl Clone for UntypedEnt

pub fn clone(&self) -> UntypedEnt

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UntypedEnt

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

Formats the value using the given formatter.

impl Default for UntypedEnt

pub fn default() -> Self

Creates an untyped ent with the ephemeral id

impl Display for UntypedEnt

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

Formats the value using the given formatter.

impl Ent for UntypedEnt

pub fn id(&self) -> Id

Represents the unique id associated with each entity instance

Examples

use entity::{Ent, UntypedEnt};

let ent = UntypedEnt::empty_with_id(999);
assert_eq!(ent.id(), 999);

pub fn set_id(&mut self, id: Id)

Updates the id of this ent, useful for databases that want to adjust the id or when you want to produce a clone of the ent in a database by resetting its id to ephemeral prior to storing it

pub fn type(&self) -> &str

Represents a unique type associated with the entity, used for lookups, indexing by type, and conversions

Examples

use entity::{UntypedEnt, Ent};

let ent = UntypedEnt::default();
assert_eq!(ent.r#type(), "entity::ent::UntypedEnt");

pub fn created(&self) -> u64

Represents the time when the instance of the ent was created as the milliseconds since epoch (1970-01-01 00:00:00 UTC)

pub fn last_updated(&self) -> u64

Represents the time when the instance of the ent was last updated as the milliseconds since epoch (1970-01-01 00:00:00 UTC)

pub fn mark_updated(&mut self) -> Result<(), EntMutationError>

Updates the local, internal timestamp of this ent instance

pub fn field_definitions(&self) -> Vec<FieldDefinition>

Represents the definitions of fields contained within the ent instance

Examples

use entity::{Ent, UntypedEnt, Field, FieldDefinition, ValueType};
use std::str::FromStr;

let fields = vec![
    Field::new("field1", 123u8),
    Field::new("field2", "some text"),
];
let ent = UntypedEnt::from_collections(0, fields.iter().cloned(), vec![]);

let defs = ent.field_definitions();
assert_eq!(defs.len(), 2);
assert!(defs.contains(&FieldDefinition::new(
    "field1",
    ValueType::from_str("u8").unwrap(),
)));
assert!(defs.contains(&FieldDefinition::new(
    "field2",
    ValueType::Text,
)));

pub fn field_names(&self) -> Vec<String>

Represents the names of fields contained within the ent instance

Examples

use entity::{Ent, UntypedEnt, Field};

let fields = vec![
    Field::new("field1", 123u8),
    Field::new("field2", "some text"),
];
let ent = UntypedEnt::from_collections(0, fields.iter().cloned(), vec![]);

let names = ent.field_names();
assert_eq!(names.len(), 2);
assert!(names.contains(&String::from("field1")));
assert!(names.contains(&String::from("field2")));

pub fn field(&self, name: &str) -> Option<Value>

Returns a copy of the value of the field with the specified name

Examples

use entity::{Ent, UntypedEnt, Field, Value};

let fields = vec![
    Field::new("field1", 123u8),
    Field::new("field2", "some text"),
];
let ent = UntypedEnt::from_collections(0, fields.iter().cloned(), vec![]);

assert_eq!(ent.field("field1"), Some(Value::from(123u8)));
assert_eq!(ent.field("unknown"), None);

pub fn update_field(
    &mut self,
    name: &str,
    value: Value
) -> Result<Value, EntMutationError>

Updates the local value of a field with the specified name, returning the old field value if updated

Examples

use entity::{Ent, UntypedEnt, Field, Value};

let fields = vec![
    Field::new("field1", 123u8),
    Field::new("field2", "some text"),
];
let mut ent = UntypedEnt::from_collections(0, fields.iter().cloned(), vec![]);

ent.update_field("field1", Value::from(5u8)).unwrap();
assert_eq!(ent.field("field1"), Some(Value::from(5u8)));

pub fn edge_definitions(&self) -> Vec<EdgeDefinition>

Represents the definitions of edges contained within the ent instance

Examples

use entity::{Ent, UntypedEnt, Edge, EdgeDefinition, EdgeValueType};
use std::str::FromStr;

let edges = vec![
    Edge::new("edge1", 99),
    Edge::new("edge2", vec![1, 2, 3]),
];
let ent = UntypedEnt::from_collections(0, vec![], edges);

let defs = ent.edge_definitions();
assert_eq!(defs.len(), 2);
assert!(defs.contains(&EdgeDefinition::new(
    "edge1",
    EdgeValueType::One,
)));
assert!(defs.contains(&EdgeDefinition::new(
    "edge2",
    EdgeValueType::Many,
)));

pub fn edge_names(&self) -> Vec<String>

Returns a list of names of edges contained by the ent

Examples

use entity::{Ent, UntypedEnt, Edge};

let edges = vec![
    Edge::new("edge1", 99),
    Edge::new("edge2", vec![1, 2, 3]),
];
let ent = UntypedEnt::from_collections(0, vec![], edges);

let names = ent.edge_names();
assert_eq!(names.len(), 2);
assert!(names.contains(&String::from("edge1")));
assert!(names.contains(&String::from("edge2")));

pub fn edge(&self, name: &str) -> Option<EdgeValue>

Returns a copy of the value of the edge with the specified name

Examples

use entity::{Ent, UntypedEnt, Edge, EdgeValue};

let edges = vec![
    Edge::new("edge1", 99),
    Edge::new("edge2", vec![1, 2, 3]),
];
let ent = UntypedEnt::from_collections(0,  vec![], edges);

assert_eq!(ent.edge("edge1"), Some(EdgeValue::One(99)));
assert_eq!(ent.edge("edge2"), Some(EdgeValue::Many(vec![1, 2, 3])));
assert_eq!(ent.edge("unknown"), None);

pub fn update_edge(
    &mut self,
    name: &str,
    value: EdgeValue
) -> Result<EdgeValue, EntMutationError>

Updates the local value of an edge with the specified name, returning the old edge value if updated

Examples

use entity::{Ent, UntypedEnt, Edge, EdgeValue};

let edges = vec![
    Edge::new("edge1", 99),
    Edge::new("edge2", vec![1, 2, 3]),
];
let mut ent = UntypedEnt::from_collections(0,  vec![], edges);

ent.update_edge("edge1", EdgeValue::One(123)).unwrap();
assert_eq!(ent.edge("edge1"), Some(EdgeValue::One(123)));

pub fn connect(&mut self, database: WeakDatabaseRc)

Connects ent to the given boxed database trait object so all future database-related operations will be performed against this database

pub fn disconnect(&mut self)

Disconnects ent from the given database. All future database-related operations will fail with a disconnected database error

pub fn is_connected(&self) -> bool

Returns true if ent is currently connected to a database

pub fn load_edge(&self, name: &str) -> DatabaseResult<Vec<Box<dyn Ent>>>

Loads the ents connected by the edge with the given name

Requires ent to be connected to a database

pub fn refresh(&mut self) -> DatabaseResult<()>

Refreshes ent by checking database for latest version and returning it

Requires ent to be connected to a database

pub fn commit(&mut self) -> DatabaseResult<()>

Saves the ent to the database, updating this local instance's id if the database has reported a new id

Requires ent to be connected to a database

pub fn remove(&self) -> DatabaseResult<bool>

Removes self from database, returning true if successful

Requires ent to be connected to a database

pub fn fields(&self) -> Vec<Field>

Returns a copy of all fields contained by the ent and their associated values

pub fn edges(&self) -> Vec<Edge>

Returns a copy of all edges contained by the ent and their associated values

impl EntType for UntypedEnt

pub fn type_str() -> &'static str

Represents a unique type associated with the entity, used for lookups, indexing by type, and conversions

Examples

use entity::{UntypedEnt, EntType};

assert_eq!(UntypedEnt::type_str(), "entity::ent::UntypedEnt");

impl Eq for UntypedEnt

impl PartialEq<UntypedEnt> for UntypedEnt

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

Untyped Ents are considered equal if their ids, fields, edges, creation date, and updated date are all equal

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.