Trait entity::Ent[−][src]

pub trait Ent: AsAny + DynClone + Send + Sync {

Show methods    fn id(&self) -> Id;

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

    fn type(&self) -> &str;

    fn created(&self) -> u64;

    fn last_updated(&self) -> u64;

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

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

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

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

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

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

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

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

    fn disconnect(&mut self);

    fn is_connected(&self) -> bool;

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

    fn clear_cache(&mut self);

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

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

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

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

    fn field_names(&self) -> Vec<String> { ... }

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

    fn fields(&self) -> Vec<Field> { ... }

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

    fn edge_names(&self) -> Vec<String> { ... }

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

    fn edges(&self) -> Vec<Edge> { ... }

}

Represents the interface for a generic entity whose fields and edges can be accessed by str name regardless of compile-time characteristics

Based on https://www.usenix.org/system/files/conference/atc13/atc13-bronson.pdf

Required methods

fn id(&self) -> Id[src]

Represents the unique id associated with each entity instance

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

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 time when the instance of the ent was last updated to the current time in milliseconds since epoch (1970-01-01 00:00:00 UTC)

fn field_definitions(&self) -> Vec<FieldDefinition>[src]

Returns a list of definitions for fields contained by the ent

fn field(&self, name: &str) -> Option<Value>[src]

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

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

Updates the local value of a field with the specified name, returning the old field value if updated. This will also update the last updated time for the ent.

fn edge_definitions(&self) -> Vec<EdgeDefinition>[src]

Returns a list of definitions for edges contained by the ent

fn edge(&self, name: &str) -> Option<EdgeValue>[src]

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

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

Updates the local value of an edge with the specified name, returning the old edge value if updated. This will also update the last updated time for the ent.

fn connect(&mut self, database: WeakDatabaseRc)[src]

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

fn disconnect(&mut self)[src]

Disconnects ent from any associated database. All future database 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 clear_cache(&mut self)[src]

Clears out any locally-cached data for the ent

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

Loading content...

Provided methods

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

Returns definition for the field with specified name

fn field_names(&self) -> Vec<String>[src]

Returns a list of names of fields contained by the ent

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

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

fn fields(&self) -> Vec<Field>[src]

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

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

Returns definition for the edge with specified name

fn edge_names(&self) -> Vec<String>[src]

Returns a list of names of edges contained by the ent

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

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

fn edges(&self) -> Vec<Edge>[src]

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

Loading content...

Implementations

impl dyn Ent[src]

Implementation for a generic trait object of Ent that provides methods to downcast into a concrete type

pub fn as_ent<E: Ent>(&self) -> Option<&E>[src]

Attempts to convert this dynamic Ent ref into a concrete Ent ref by downcasting

pub fn as_mut_ent<E: Ent>(&mut self) -> Option<&mut E>[src]

Attempts to convert this dynamic Ent mutable ref into a concrete Ent mutable ref by downcasting

pub fn to_ent<E: Ent>(&self) -> Option<E>[src]

Attempts to convert this dynamic Ent ref into a concrete ent by downcasting and then cloning

Implementors

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]

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]

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 clear_cache(&mut self)[src]

Clears the locally-cached, computed fields of the ent

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

Loading content...