Struct Edge 

#[repr(C)]
pub struct Edge<T, S, K, Idx = Udx>
where
    S: RawDomain<Key = VertexId<Idx>>,
{ /* private fields */ }

The Edge implementation essentially wraps the Link type with a Weight

Implementations

impl<T, S, K, Idx> Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

pub const fn new(edge: Link<S, K, Idx>, weight: Weight<T>) -> Self

creates a new instance from the given edge and weight

pub fn from_parts(id: EdgeId<Idx>, nodes: S, weight: Weight<T>) -> Self

create a new instance of the Edge from the given id, nodes, and weight

pub fn from_domain(nodes: S) -> Self

where Idx: Default, T: Default,

creates a new edge with the given nodes

pub fn from_id(id: EdgeId<Idx>) -> Self

where S: Default, T: Default,

creates a new edge with the given id

pub fn from_link(edge: Link<S, K, Idx>) -> Self

where T: Default,

creates a new edge with the given id

pub fn from_weight(weight: Weight<T>) -> Self

where Idx: Default, S: Default,

creates a new instance from the given value

pub const fn link(&self) -> &Link<S, K, Idx>

returns an immutable reference to the edge

pub const fn link_mut(&mut self) -> &mut Link<S, K, Idx>

returns a mutable reference to the edge

pub const fn weight(&self) -> &Weight<T>

returns an immutable reference to the weight

pub const fn weight_mut(&mut self) -> &mut Weight<T>

returns a mutable reference to the weight

pub const fn id(&self) -> &EdgeId<Idx>

returns an immutable reference to the id

pub const fn id_mut(&mut self) -> &mut EdgeId<Idx>

returns a mutable reference to the id

pub const fn domain(&self) -> &S

returns an immutable reference to the nodes

pub const fn domain_mut(&mut self) -> &mut S

returns a mutable reference to the nodes

pub fn set_domain(&mut self, nodes: S) -> &mut Self

updates the nodes and returns a mutable reference to the instance

pub fn set_link(&mut self, link: Link<S, K, Idx>) -> &mut Self

updates the link and returns a mutable reference to the instance

pub fn set_weight(&mut self, weight: Weight<T>) -> &mut Self

updates the weight and returns a mutable reference to the instance

pub fn with_id(self, id: EdgeId<Idx>) -> Self

consumes the current instance to create another with the given id.

pub fn with_domain<S2: Domain<Idx>>(self, nodes: S2) -> Edge<T, S2, K, Idx>

consumes the current instance to create another with the given nodes.

pub fn with_weight<U>(self, weight: Weight<U>) -> Edge<U, S, K, Idx>

consumes the current instance to create another with the given weight.

pub fn contains<Q>(&self, index: &Q) -> bool

where VertexId<Idx>: Borrow<Q>, Q: ?Sized + PartialEq, Idx: PartialEq, for<'a> &'a S: IntoIterator<Item = &'a VertexId<Idx>>,

returns true if the edge contains the given vertex

pub fn is_empty(&self) -> bool

returns true if the edge is empty

pub fn len(&self) -> usize

returns the number of nodes in the edge

impl<T, S, Idx> Edge<T, S, Directed, Idx>

where Idx: RawIndex, S: Domain<Idx>,

pub fn directed(id: EdgeId<Idx>, nodes: S, weight: T) -> Self

returns a new Directed hypersurface with the given id and nodes

impl<T, S, I> Edge<T, S, Undirected, I>

where I: RawIndex, S: Domain<I>,

pub fn undirected(id: EdgeId<I>, nodes: S, weight: T) -> Self

creates a new Undirected hypersurface with the given id and nodes

Methods from Deref<Target = Link<S, K, Idx>>

pub fn id(&self) -> &EdgeId<Ix>

returns an immutable reference to the id

pub fn domain(&self) -> &S

returns an immutable reference to the nodes

pub fn domain_mut(&mut self) -> &mut S

returns a mutable reference to the nodes

pub fn set_domain(&mut self, nodes: S) -> &mut Self

updates the nodes and returns a mutable reference to the instance

pub fn contains<Q>(&self, index: &Q) -> bool

where Ix: PartialEq, Q: ?Sized + PartialEq, VertexId<Ix>: Borrow<Q>, for<'a> &'a S: IntoIterator<Item = &'a VertexId<Ix>>,

returns true if the edge contains the given vertex index

pub fn contains_all<Q, I>(&self, indices: I) -> bool

where Ix: PartialEq, I: IntoIterator<Item = Q>, Q: PartialEq, VertexId<Ix>: Borrow<Q>, for<'a> &'a S: IntoIterator<Item = &'a VertexId<Ix>>,

returns true if the edge contains all the given vertex indices

pub fn len(&self) -> usize

returns the number of vertices in the edge

pub fn is_empty(&self) -> bool

returns true if the edge has no vertices

Methods from Deref<Target = EdgeId<Idx>>

pub fn as_ptr(&self) -> *const T

returns a pointer to the inner value

pub fn as_mut_ptr(&mut self) -> *mut T

returns a mutable pointer to the inner value

pub fn as_raw_box(&self) -> Box<dyn RawIndex>

where T: Clone,

converts the a reference to a boxed raw index trait object

pub fn get(&self) -> &T

returns an immutable reference to the inner value

pub fn get_mut(&mut self) -> &mut T

returns a mutable reference to the inner value

pub fn replace(&mut self, index: T) -> T

replace and return the old value after replacing it with the given value

pub fn set(&mut self, value: T) -> &mut Self

set the index to the given value

pub fn swap(&mut self, other: &mut Self)

swap the values of two indices

pub fn take(&mut self) -> T

where T: Default,

take the value and replace it with the default value

pub fn dec_inplace(&mut self)

where T: SubAssign + One,

mutably decrements the index value by one

pub fn inc_inplace(&mut self)

where T: Copy + AddAssign + One,

mutably increments the index value by 1

pub fn step(&mut self) -> IndexResult<Self>

where T: AddStep<Output = T>,

increments the current index and returns the previous instance of the index.

    use rshyper_core::EdgeId;
    let mut edge_id = EdgeId::<usize>::zero();
    let e0 = edge_id.step()?;
    let e1 = edge_id.step()?;
    let e2 = edge_id.step()?;
    assert_eq!(e0.get(), &0);
    assert_eq!(e1.get(), &1);
    assert_eq!(e2.get(), &2);

pub fn step_with<F>(&mut self, f: F) -> IndexResult<Self>

where F: FnOnce(&T) -> T,

replaces the current value with the next one computed using the provided function and returns the previous instance of the index.

pub fn rand_step(&mut self) -> Self

where StandardUniform: Distribution<T>,

replaces the current value with a randomly generated value and returns a new instance of IndexBase with the previous value.

pub fn atomic_next(&mut self) -> Self

atomically generates a the next index, replacing the current value with the generated one and returning the previous value.

pub fn generate(&mut self) -> Self

the generate is useful for instances where the type Idx of the IndexBase is not generalized, automatically using random number generation if the rand feature is enabled, or an atomic counter otherwise. The method is also useful in that it generates usize indices, whcih are the most common instances, yet aren’t direct implementors of StandardUniform.

Trait Implementations

impl<T, S, K, Idx> AsMut<Weight<T>> for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

fn as_mut(&mut self) -> &mut Weight<T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, S, K, Idx> AsRef<Weight<T>> for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

fn as_ref(&self) -> &Weight<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<E, S, I, K> BinaryLayout for Edge<E, S, K, I>

where E: BinaryLayout, S: BinaryDomain<I>, I: RawIndex, K: GraphType,

fn lhs(&self) -> &VertexId<I>

fn rhs(&self) -> &VertexId<I>

impl<T, S, K, Idx> Borrow<IndexBase<Idx, EdgeIndex>> for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

fn borrow(&self) -> &EdgeId<Idx>

Immutably borrows from an owned value.

impl<T, S, K, Idx> BorrowMut<IndexBase<Idx, EdgeIndex>> for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

fn borrow_mut(&mut self) -> &mut EdgeId<Idx>

Mutably borrows from an owned value.

impl<T: Clone, S, K: Clone, Idx: Clone> Clone for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>> + Clone,

fn clone(&self) -> Edge<T, S, K, Idx>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S, K, Idx, Q> Contains<Q> for Edge<T, S, K, Idx>

where Q: PartialEq, S: Domain<Idx>, K: GraphType, Idx: RawIndex + PartialEq, for<'a> &'a S: IntoIterator<Item = &'a VertexId<Idx>>,

type Key = IndexBase<Idx>

fn contains(&self, query: &Q) -> bool

where Self::Key: Borrow<Q>,

checks if the container contains the given index

impl<T, S, K, Idx> Debug for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, T: Debug, S: Domain<Idx> + Debug,

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

Formats the value using the given formatter.

impl<T, S, K, Idx> Default for Edge<T, S, K, Idx>

where Idx: Default + RawIndex, K: GraphType, T: Default, S: Domain<Idx> + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T, S, K, Idx> Deref for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

type Target = Link<S, K, Idx>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, S, K, Idx> DerefMut for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T, S, K, Idx> Deserialize<'de> for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>> + Deserialize<'de>, T: Deserialize<'de>, K: Deserialize<'de>, Idx: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, S, K, Idx> Display for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, T: Display, S: Domain<Idx> + Debug,

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

Formats the value using the given formatter.

impl<T, S, K, Idx> From<Edge<T, S, K, Idx>> for Link<S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

fn from(facet: Edge<T, S, K, Idx>) -> Self

Converts to this type from the input type.

impl<T, S, K, Idx> From<IndexBase<Idx, EdgeIndex>> for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Default + Domain<Idx>, T: Default,

fn from(id: EdgeId<Idx>) -> Self

Converts to this type from the input type.

impl<T, S, K, Idx> From<Link<S, K, Idx>> for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>, T: Default,

fn from(edge: Link<S, K, Idx>) -> Self

Converts to this type from the input type.

impl<T: Hash, S, K: Hash, Idx: Hash> Hash for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>> + Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord, S, K: Ord, Idx: Ord> Ord for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>> + Ord,

fn cmp(&self, other: &Edge<T, S, K, Idx>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, S, K: PartialEq, Idx: PartialEq> PartialEq for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>> + PartialEq,

fn eq(&self, other: &Edge<T, S, K, Idx>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd, S, K: PartialOrd, Idx: PartialOrd> PartialOrd for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>> + PartialOrd,

fn partial_cmp(&self, other: &Edge<T, S, K, Idx>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, S, Idx, K> RawLayout for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

type Kind = K

type Index = Idx

type Store = S

fn index(&self) -> &EdgeId<Idx>

returns an immutable reference to the edge index

fn domain(&self) -> &S

returns a reference to the domain of the edge

fn domain_mut(&mut self) -> &mut S

returns a mutable reference to the domain of the edge

fn is_directed(&self) -> bool

returns true if the edge is directed, false otherwise.

fn is_undirected(&self) -> bool

returns true if the edge is undirected, false otherwise.

impl<T, S, Idx, K> RawSurface<T> for Edge<T, S, K, Idx>

where Idx: RawIndex, K: GraphType, S: Domain<Idx>,

fn weight(&self) -> &Weight<T>

Returns the index of the edge.

fn weight_mut(&mut self) -> &mut Weight<T>

returns a mutable reference to the edge data.

fn replace_weight(&mut self, weight: Weight<T>) -> Weight<T>

replace the weight of the edge with a new one, returning the previous value

fn set_weight(&mut self, weight: T) -> &mut Self

overwrites the weight of the edge with a new one and returns a mutable reference to the edge.

fn swap_weight(&mut self, weight: &mut Weight<T>)

swap the weight of the edge with another weight

fn take_weight(&mut self) -> Weight<T>

where T: Default,

take the weight of the edge, replacing it with a default value

impl<T, S, K, Idx> Serialize for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>> + Serialize, T: Serialize, K: Serialize, Idx: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy, S, K: Copy, Idx: Copy> Copy for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>> + Copy,

impl<T: Eq, S, K: Eq, Idx: Eq> Eq for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>> + Eq,

impl<T, S, K, Idx> StructuralPartialEq for Edge<T, S, K, Idx>

where S: RawDomain<Key = VertexId<Idx>>,