Struct GraphElements 

pub struct GraphElements<'a, K, V> { /* private fields */ }

Read-only view over one graph element collection.

This keeps Graph’s public API from committing callers to its storage type while preserving the common map-like read operations adapters need for deterministic traversal and lookup.

Implementations

impl<'a, K, V> GraphElements<'a, K, V>

pub fn len(&self) -> usize

Returns the number of elements.

Examples found in repository

examples/build_graph.rs (line 43)

fn main() {
    let node_id = NodeId::from_u128(2);
    let mut graph = Graph::new(GraphId::from_u128(1));

    let mut tx = GraphTransaction::new().with_label("add source node");
    tx.push(GraphOp::AddNode {
        id: node_id,
        node: make_node("demo.source", 10.0, 20.0),
    });
    tx.apply_to(&mut graph).expect("transaction applies");

    assert_eq!(graph.nodes().len(), 1);
    assert_eq!(
        graph.nodes()[&node_id].kind,
        NodeKindKey::new("demo.source")
    );
}

pub fn is_empty(&self) -> bool

Returns true when this collection has no elements.

pub fn contains_key<Q>(&self, key: &Q) -> bool

where K: Borrow<Q> + Ord, Q: Ord + ?Sized,

Returns true when the collection contains key.

pub fn get<Q>(&self, key: &Q) -> Option<&'a V>

where K: Borrow<Q> + Ord, Q: Ord + ?Sized,

Returns an element by id.

pub fn iter(&self) -> GraphElementIter<'a, K, V>

Returns key-value pairs in deterministic id order.

pub fn keys(&self) -> GraphElementKeys<'a, K, V>

Returns ids in deterministic order.

pub fn values(&self) -> GraphElementValues<'a, K, V>

Returns element values in deterministic id order.

Trait Implementations

impl<'a, K: Clone, V: Clone> Clone for GraphElements<'a, K, V>

fn clone(&self) -> GraphElements<'a, K, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, K: Copy, V: Copy> Copy for GraphElements<'a, K, V>

impl<'a, K: Debug, V: Debug> Debug for GraphElements<'a, K, V>

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

Formats the value using the given formatter.

impl<'a, K, V> Eq for GraphElements<'a, K, V>

where K: Ord + Eq, V: Eq,

impl<'a, K, V> Index<&K> for GraphElements<'a, K, V>

where K: Ord,

type Output = V

The returned type after indexing.

fn index(&self, key: &K) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, K, V> IntoIterator for GraphElements<'a, K, V>

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = GraphElementIter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, 'b, K, V> PartialEq<GraphElements<'b, K, V>> for GraphElements<'a, K, V>

where K: Ord + PartialEq, V: PartialEq,

fn eq(&self, other: &GraphElements<'b, K, V>) -> 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.