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

Trait Implementations

impl Clone for UntypedEnt

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

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

Formats the value using the given formatter.

impl Default for UntypedEnt

fn default() -> Self

Creates an untyped ent with the ephemeral id

impl Display for UntypedEnt

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

Formats the value using the given formatter.

impl Ent for UntypedEnt

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

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

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

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)

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)

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

Updates the local, internal timestamp of this ent instance

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

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>

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>

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>

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>

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>

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>

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>

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)

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)

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

fn is_connected(&self) -> bool

Returns true if ent is currently connected to a database

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

fn clear_cache(&mut self)

Clears the locally-cached, computed fields of the ent

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

Refreshes ent by checking database for latest version and returning it

Requires ent to be connected to a database

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

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

Removes self from database, returning true if successful

Requires ent to be connected to a database

fn field_definition(&self, name: &str) -> Option<FieldDefinition>

Returns definition for the field with specified name

fn field_type(&self, name: &str) -> Option<ValueType>

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

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

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

fn edge_definition(&self, name: &str) -> Option<EdgeDefinition>

Returns definition for the edge with specified name

fn edge_type(&self, name: &str) -> Option<EdgeValueType>

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

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

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

impl EntType for UntypedEnt

fn type_data() -> EntTypeData

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

Examples

use entity::{UntypedEnt, EntType, EntTypeData};

assert!(matches!(
    UntypedEnt::type_data(),
    EntTypeData::Concrete { ty: "entity::ent::UntypedEnt" },
));

fn type_str() -> &'static str

Returns a static str that represents the unique type for an ent

fn is_concrete_type() -> bool

Indicates whether the ent represents a concrete type (like a struct) or a wrapper around one of many types (like an enum)

fn wrapped_tys() -> Option<HashSet<&'static str>>

Represents the types that this ent wraps if it is not a concrete ent

impl Eq for UntypedEnt

impl PartialEq<UntypedEnt> for UntypedEnt

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 !=.