Struct entity::UntypedEnt [−][src]
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
[src]
pub fn new(
id: Id,
fields: HashMap<String, Field>,
edges: HashMap<String, Edge>
) -> Self
[src]
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
[src]
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
[src]
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
Trait Implementations
impl Clone for UntypedEnt
[src]
fn clone(&self) -> UntypedEnt
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for UntypedEnt
[src]
impl Default for UntypedEnt
[src]
impl Display for UntypedEnt
[src]
impl Ent for UntypedEnt
[src]
fn id(&self) -> Id
[src]
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);
fn set_id(&mut self, id: Id)
[src]
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
fn type(&self) -> &str
[src]
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");
fn created(&self) -> u64
[src]
Represents the time when the instance of the ent was created as the milliseconds since epoch (1970-01-01 00:00:00 UTC)
fn last_updated(&self) -> u64
[src]
Represents the time when the instance of the ent was last updated as the milliseconds since epoch (1970-01-01 00:00:00 UTC)
fn mark_updated(&mut self) -> Result<(), EntMutationError>
[src]
Updates the local, internal timestamp of this ent instance
fn field_definitions(&self) -> Vec<FieldDefinition>
[src]
Represents the definitions of fields contained within the ent instance
Examples
use entity::{Ent, UntypedEnt, Field, FieldDefinition, Value, ValueType}; use std::str::FromStr; let fields = vec![ Field::new("field1", 123u8), Field::new("field2", Value::from("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, )));
fn field_names(&self) -> Vec<String>
[src]
Represents the names of fields contained within the ent instance
Examples
use entity::{Ent, UntypedEnt, Field, Value}; let fields = vec![ Field::new("field1", 123u8), Field::new("field2", Value::from("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")));
fn field(&self, name: &str) -> Option<Value>
[src]
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", Value::from("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);
fn update_field(
&mut self,
name: &str,
value: Value
) -> Result<Value, EntMutationError>
[src]
&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", Value::from("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)));
fn edge_definitions(&self) -> Vec<EdgeDefinition>
[src]
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, )));
fn edge_names(&self) -> Vec<String>
[src]
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")));
fn edge(&self, name: &str) -> Option<EdgeValue>
[src]
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);
fn update_edge(
&mut self,
name: &str,
value: EdgeValue
) -> Result<EdgeValue, EntMutationError>
[src]
&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)));
fn connect(&mut self, database: WeakDatabaseRc)
[src]
Connects ent to the given boxed database trait object so all future database-related operations will be performed against this database
fn disconnect(&mut self)
[src]
Disconnects ent from the given database. All future database-related operations will fail with a disconnected database error
fn is_connected(&self) -> bool
[src]
Returns true if ent is currently connected to a database
fn load_edge(&self, name: &str) -> DatabaseResult<Vec<Box<dyn Ent>>>
[src]
Loads the ents connected by the edge with the given name
Requires ent to be connected to a database
fn refresh(&mut self) -> DatabaseResult<()>
[src]
Refreshes ent by checking database for latest version and returning it
Requires ent to be connected to a database
fn commit(&mut self) -> DatabaseResult<()>
[src]
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
fn remove(&self) -> DatabaseResult<bool>
[src]
Removes self from database, returning true if successful
Requires ent to be connected to a database
fn field_type(&self, name: &str) -> Option<ValueType>
[src]
fn fields(&self) -> Vec<Field>
[src]
fn edge_type(&self, name: &str) -> Option<EdgeValueType>
[src]
fn edges(&self) -> Vec<Edge>
[src]
impl EntType for UntypedEnt
[src]
fn type_str() -> &'static str
[src]
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
[src]
impl PartialEq<UntypedEnt> for UntypedEnt
[src]
Auto Trait Implementations
impl !RefUnwindSafe for UntypedEnt
impl Send for UntypedEnt
impl Sync for UntypedEnt
impl Unpin for UntypedEnt
impl !UnwindSafe for UntypedEnt
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> DynClone for T where
T: Clone,
[src]
T: Clone,
pub fn __clone_box(&self, Private) -> *mut ()
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,