Enum entity::EdgeValue

pub enum EdgeValue {
    MaybeOne(Option<Id>),
    One(Id),
    Many(Vec<Id>),
}

Represents the value of an edge, which is some collection of ent ids

Variants

MaybeOne(Option<Id>)

Edge can potentially have one outward connection

One(Id)

Edge can have exactly one outward connection

Many(Vec<Id>)

Edge can have many outward connections

Implementations

impl EdgeValue

pub fn to_ids(&self) -> Vec<Id>

Produces all ids of ents referenced by this edge’s value

Examples

For an optional edge, this can produce a vec of size 0 or 1:

use entity::EdgeValue;

let v = EdgeValue::MaybeOne(None);
assert!(v.to_ids().is_empty());

let v = EdgeValue::MaybeOne(Some(999));
assert_eq!(v.to_ids(), vec![999]);

For a guaranteed edge of 1, this will always produce a vec of size 1:

use entity::EdgeValue;

let v = EdgeValue::One(999);
assert_eq!(v.to_ids(), vec![999]);

For an edge of many ids, this will produce a vec of equal size:

use entity::EdgeValue;

let v = EdgeValue::Many(vec![1, 2, 3, 4]);
assert_eq!(v.to_ids(), vec![1, 2, 3, 4]);

pub fn to_type(&self) -> EdgeValueType

Converts the value to its associated type

Examples

use entity::{EdgeValue, EdgeValueType};

let v = EdgeValue::MaybeOne(None);
assert_eq!(v.to_type(), EdgeValueType::MaybeOne);

let v = EdgeValue::One(999);
assert_eq!(v.to_type(), EdgeValueType::One);

let v = EdgeValue::Many(vec![1, 2, 3]);
assert_eq!(v.to_type(), EdgeValueType::Many);

pub fn add_ids(
    &mut self,
    into_ids: impl IntoIterator<Item = Id>
) -> Result<(), EdgeValueMutationError>

Adds the provided ids to the edge value, failing if the ids would exceed the maximum allowed by the edge with current ids included

Examples

If edge is an optional, single value, this will fail if the edge already has a value or is provided more than one id. Otherwise, it will succeed.

use entity::EdgeValue;

let mut v = EdgeValue::MaybeOne(Some(1));
assert!(v.add_ids(vec![2]).is_err());
assert!(v.add_ids(vec![]).is_ok());
assert_eq!(v, EdgeValue::MaybeOne(Some(1)));

let mut v = EdgeValue::MaybeOne(None);
assert!(v.add_ids(vec![2, 3]).is_err());
assert_eq!(v, EdgeValue::MaybeOne(None));

let mut v = EdgeValue::MaybeOne(None);
assert!(v.add_ids(vec![]).is_ok());
assert_eq!(v, EdgeValue::MaybeOne(None));

let mut v = EdgeValue::MaybeOne(None);
assert!(v.add_ids(vec![1]).is_ok());
assert_eq!(v, EdgeValue::MaybeOne(Some(1)));

If an edge is exactly one value, this will fail unless an empty list of ids is given as we cannot add any more edge ids.

use entity::EdgeValue;

let mut v = EdgeValue::One(999);
assert!(v.add_ids(vec![1]).is_err());
assert_eq!(v, EdgeValue::One(999));

let mut v = EdgeValue::One(999);
assert!(v.add_ids(vec![]).is_ok());
assert_eq!(v, EdgeValue::One(999));

If an edge can have many ids, this will succeed and append those ids to the end of the list.

use entity::EdgeValue;

let mut v = EdgeValue::Many(vec![]);
assert!(v.add_ids(vec![1, 2, 3]).is_ok());
assert_eq!(v, EdgeValue::Many(vec![1, 2, 3]));

let mut v = EdgeValue::Many(vec![1, 2, 3]);
assert!(v.add_ids(vec![4, 5, 6]).is_ok());
assert_eq!(v, EdgeValue::Many(vec![1, 2, 3, 4, 5, 6]));

pub fn remove_ids(
    &mut self,
    into_ids: impl IntoIterator<Item = Id>
) -> Result<(), EdgeValueMutationError>

Removes the provided ids from the edge value, failing if the ids would exceed the minimum allowed by the edge with current ids possibly removed

Examples

If edge is an optional, single value, this will never fail as this can either result in the value retaining its id or becoming none.

use entity::EdgeValue;

let mut v = EdgeValue::MaybeOne(Some(1));
assert!(v.remove_ids(vec![2, 3]).is_ok());
assert_eq!(v, EdgeValue::MaybeOne(Some(1)));

let mut v = EdgeValue::MaybeOne(Some(1));
assert!(v.remove_ids(vec![1, 2, 3]).is_ok());
assert_eq!(v, EdgeValue::MaybeOne(None));

let mut v = EdgeValue::MaybeOne(None);
assert!(v.remove_ids(vec![2, 3]).is_ok());
assert_eq!(v, EdgeValue::MaybeOne(None));

let mut v = EdgeValue::MaybeOne(None);
assert!(v.remove_ids(vec![]).is_ok());
assert_eq!(v, EdgeValue::MaybeOne(None));

If an edge is exactly one value, this will fail if it would cause the value to lose its id.

use entity::EdgeValue;

let mut v = EdgeValue::One(999);
assert!(v.remove_ids(vec![999]).is_err());
assert_eq!(v, EdgeValue::One(999));

let mut v = EdgeValue::One(999);
assert!(v.remove_ids(vec![1, 2, 3]).is_ok());
assert_eq!(v, EdgeValue::One(999));

let mut v = EdgeValue::One(999);
assert!(v.remove_ids(vec![]).is_ok());
assert_eq!(v, EdgeValue::One(999));

If an edge can have many ids, this will succeed and remove all ids found within the value.

use entity::EdgeValue;

let mut v = EdgeValue::Many(vec![]);
assert!(v.remove_ids(vec![1, 2, 3]).is_ok());
assert_eq!(v, EdgeValue::Many(vec![]));

let mut v = EdgeValue::Many(vec![1, 2, 3]);
assert!(v.remove_ids(vec![4, 5, 6]).is_ok());
assert_eq!(v, EdgeValue::Many(vec![1, 2, 3]));

let mut v = EdgeValue::Many(vec![1, 2, 3]);
assert!(v.remove_ids(vec![1, 3]).is_ok());
assert_eq!(v, EdgeValue::Many(vec![2]));

Trait Implementations

impl Clone for EdgeValue

fn clone(&self) -> EdgeValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EdgeValue

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

Formats the value using the given formatter.

impl Eq for EdgeValue

impl<'_enum> From<&'_enum EdgeValue> for EdgeValueType

fn from(val: &'_enum EdgeValue) -> EdgeValueType

Performs the conversion.

impl From<BTreeSet<usize>> for EdgeValue

fn from(x: BTreeSet<Id>) -> Self

Performs the conversion.

impl From<BinaryHeap<usize>> for EdgeValue

fn from(x: BinaryHeap<Id>) -> Self

Performs the conversion.

impl From<EdgeValue> for EdgeValueType

fn from(val: EdgeValue) -> EdgeValueType

Performs the conversion.

impl From<HashSet<usize, RandomState>> for EdgeValue

fn from(x: HashSet<Id>) -> Self

Performs the conversion.

impl From<LinkedList<usize>> for EdgeValue

fn from(x: LinkedList<Id>) -> Self

Performs the conversion.

impl From<Option<usize>> for EdgeValue

fn from(original: Option<Id>) -> EdgeValue

Performs the conversion.

impl From<Vec<usize, Global>> for EdgeValue

fn from(original: Vec<Id>) -> EdgeValue

Performs the conversion.

impl From<VecDeque<usize>> for EdgeValue

fn from(x: VecDeque<Id>) -> Self

Performs the conversion.

impl From<usize> for EdgeValue

fn from(original: Id) -> EdgeValue

Performs the conversion.

impl PartialEq<EdgeValue> for EdgeValue

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &EdgeValue) -> bool

This method tests for !=.

impl StructuralEq for EdgeValue

impl StructuralPartialEq for EdgeValue

impl TryFrom<EdgeValue> for Id

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: EdgeValue) -> Result<Self, Self::Error>

Performs the conversion.