Struct Link 

#[repr(C)]
pub struct Link<S, K, Ix = usize>
where
    S: RawDomain<Key = VertexId<Ix>>,
{ /* private fields */ }

Here, a Link essentially defines the layout of an edge within a hypergraph. The implementation is generic over the type of domain it contains, which can be a set of vertices or any other structure that implements the Domain trait.

Implementations

impl<S, K, Ix> Link<S, K, Ix>

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

pub const fn new(id: EdgeId<Ix>, domain: S) -> Self

returns a new instance using the given edge id and domain

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

where S: Default,

creates a new edge with the given id

pub fn from_domain(nodes: S) -> Self

where Ix: Default,

creates a new edge with the given nodes

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

returns an immutable 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 with_id(self, id: EdgeId<Ix>) -> Self

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

pub fn with_domain<S2: Domain<Ix>>(self, nodes: S2) -> Link<S2, K, Ix>

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

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

impl<S, Idx> Link<S, Directed, Idx>

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

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

returns a new Directed hyperedge with the given id and nodes

impl<S, Idx> Link<S, Undirected, Idx>

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

pub fn undirected(id: EdgeId<Idx>, nodes: S) -> Self

creates a new Undirected hyperedge with the given id and nodes

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<S, K, Idx> AsMut<S> for Link<S, K, Idx>

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

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

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

impl<S, K, Idx> AsRef<S> for Link<S, K, Idx>

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

fn as_ref(&self) -> &S

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

impl<S, I, K> BinaryLayout for Link<S, K, I>

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

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

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

impl<S, K, Idx> Borrow<IndexBase<Idx, EdgeIndex>> for Link<S, K, Idx>

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

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

Immutably borrows from an owned value.

impl<S, K, Idx> BorrowMut<IndexBase<Idx, EdgeIndex>> for Link<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<S, K: Clone, Ix: Clone> Clone for Link<S, K, Ix>

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

fn clone(&self) -> Link<S, K, Ix>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, K, Idx, Q> Contains<Q> for Link<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<S, K, Idx> Debug for Link<S, K, Idx>

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

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

Formats the value using the given formatter.

impl<S, K, Idx> Default for Link<S, K, Idx>

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

fn default() -> Self

Returns the “default value” for a type.

impl<S, K, Idx> Deref for Link<S, K, Idx>

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

type Target = IndexBase<Idx, EdgeIndex>

The resulting type after dereferencing.

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

Dereferences the value.

impl<S, K, Idx> DerefMut for Link<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, S, K, Ix> Deserialize<'de> for Link<S, K, Ix>

where S: RawDomain<Key = VertexId<Ix>> + Deserialize<'de>, Ix: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S, K, Idx> Display for Link<S, K, Idx>

where Idx: RawIndex, K: GraphType, 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<S, K, Idx> From<IndexBase<Idx, EdgeIndex>> for Link<S, K, Idx>

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

fn from(from: 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<S, K, Idx> From<Link<S, K, Idx>> for EdgeId<Idx>

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

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

Converts to this type from the input type.

impl<S, K, Idx> FromIterator<Idx> for Link<S, K, Idx>

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

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Idx>,

Creates a value from an iterator.

impl<S, K, Idx> FromIterator<IndexBase<Idx>> for Link<S, K, Idx>

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

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = VertexId<Idx>>,

Creates a value from an iterator.

impl<S, K: Hash, Ix: Hash> Hash for Link<S, K, Ix>

where S: RawDomain<Key = VertexId<Ix>> + 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<S, K, Idx> Layout for Link<S, K, Idx>

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

fn new(id: EdgeId<Idx>, vertices: S) -> Self

impl<S, K: Ord, Ix: Ord> Ord for Link<S, K, Ix>

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

fn cmp(&self, other: &Link<S, K, Ix>) -> 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<S, K: PartialEq, Ix: PartialEq> PartialEq for Link<S, K, Ix>

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

fn eq(&self, other: &Link<S, K, Ix>) -> 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<S, K: PartialOrd, Ix: PartialOrd> PartialOrd for Link<S, K, Ix>

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

fn partial_cmp(&self, other: &Link<S, K, Ix>) -> 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<S, K, Idx> RawLayout for Link<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<S, K, Ix> Serialize for Link<S, K, Ix>

where S: RawDomain<Key = VertexId<Ix>> + Serialize, Ix: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S, K: Copy, Ix: Copy> Copy for Link<S, K, Ix>

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

impl<S, K: Eq, Ix: Eq> Eq for Link<S, K, Ix>

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

impl<S, K, Ix> StructuralPartialEq for Link<S, K, Ix>

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