Struct NodeState 

pub struct NodeState<'graph, V, G, GH = G> { /* private fields */ }

Implementations

impl<'graph, V, G: IntoDynamic, GH: IntoDynamic> NodeState<'graph, V, G, GH>

pub fn into_dyn(self) -> NodeState<'graph, V, DynamicGraph>

impl<'graph, V, G: GraphViewOps<'graph>> NodeState<'graph, V, G>

pub fn new_from_eval(graph: G, values: Vec<V>) -> Self

where V: Clone,

Construct a node state from an eval result

Arguments

• graph: the graph view
• values: the unfiltered values (i.e., values.len() == graph.unfiltered_num_nodes()). This method handles the filtering.

pub fn new_from_eval_mapped<R: Clone>( graph: G, values: Vec<R>, map: impl Fn(R) -> V, ) -> Self

Construct a node state from an eval result, mapping values

Arguments

• graph: the graph view
• values: the unfiltered values (i.e., values.len() == graph.unfiltered_num_nodes()). This method handles the filtering.
• map: Closure mapping input to output values

pub fn new_empty(graph: G) -> Self

create a new empty NodeState

pub fn new_from_values(graph: G, values: impl Into<Arc<[V]>>) -> Self

create a new NodeState from a list of values for the node (takes care of creating an index for node filtering when needed)

pub fn new_from_map<R, S: BuildHasher>( graph: G, values: HashMap<VID, R, S>, map: impl Fn(R) -> V, ) -> Self

create a new NodeState from a HashMap of values

impl<'graph, V, G: GraphViewOps<'graph>, GH: GraphViewOps<'graph>> NodeState<'graph, V, G, GH>

pub fn new( base_graph: G, graph: GH, values: Arc<[V]>, keys: Option<Index<VID>>, ) -> Self

pub fn into_inner(self) -> (Arc<[V]>, Option<Index<VID>>)

pub fn values(&self) -> &Arc<[V]>

Trait Implementations

impl<'graph, V: Clone, G: Clone, GH: Clone> Clone for NodeState<'graph, V, G, GH>

fn clone(&self) -> NodeState<'graph, V, G, GH>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'graph, V: Debug + Clone + Send + Sync + 'graph, G: GraphViewOps<'graph>, GH: Debug + GraphViewOps<'graph>> Debug for NodeState<'graph, V, G, GH>

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

Formats the value using the given formatter.

impl<'graph, V: Send + Sync + Clone + 'graph, G: GraphViewOps<'graph>, GH: GraphViewOps<'graph>> IntoIterator for NodeState<'graph, V, G, GH>

type Item = (NodeView<'graph, G, GH>, V)

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = <NodeState<'graph, V, G, GH> as IntoIterator>::Item> + 'graph>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'graph, V: Clone + Send + Sync + 'graph, G: GraphViewOps<'graph>, GH: GraphViewOps<'graph>> NodeStateOps<'graph> for NodeState<'graph, V, G, GH>

type Graph = GH

type BaseGraph = G

type Value<'a> = &'a V where 'graph: 'a

type OwnedValue = V

fn graph(&self) -> &Self::Graph

fn base_graph(&self) -> &Self::BaseGraph

fn iter_values<'a>(&'a self) -> impl Iterator<Item = Self::Value<'a>> + 'a

where 'graph: 'a,

fn par_iter_values<'a>( &'a self, ) -> impl ParallelIterator<Item = Self::Value<'a>> + 'a

where 'graph: 'a,

fn into_iter_values(self) -> impl Iterator<Item = Self::OwnedValue> + 'graph

fn into_par_iter_values( self, ) -> impl ParallelIterator<Item = Self::OwnedValue> + 'graph

fn iter<'a>( &'a self, ) -> impl Iterator<Item = (NodeView<'a, &'a Self::BaseGraph, &'a Self::Graph>, Self::Value<'a>)> + 'a

where 'graph: 'a,

fn nodes(&self) -> Nodes<'graph, Self::BaseGraph, Self::Graph>

fn par_iter<'a>( &'a self, ) -> impl ParallelIterator<Item = (NodeView<'a, &'a <Self as NodeStateOps<'graph>>::BaseGraph, &'a <Self as NodeStateOps<'graph>>::Graph>, <Self as NodeStateOps<'graph>>::Value<'a>)>

where 'graph: 'a,

fn get_by_index( &self, index: usize, ) -> Option<(NodeView<'_, &Self::BaseGraph, &Self::Graph>, Self::Value<'_>)>

fn get_by_node<N: AsNodeRef>(&self, node: N) -> Option<Self::Value<'_>>

fn len(&self) -> usize

fn sort_by<F: Fn((NodeView<'_, &Self::BaseGraph, &Self::Graph>, &Self::OwnedValue), (NodeView<'_, &Self::BaseGraph, &Self::Graph>, &Self::OwnedValue)) -> Ordering + Sync>( &self, cmp: F, ) -> NodeState<'graph, Self::OwnedValue, Self::BaseGraph, Self::Graph>

fn sort_by_values_by<F: Fn(&Self::OwnedValue, &Self::OwnedValue) -> Ordering + Sync>( &self, cmp: F, ) -> NodeState<'graph, Self::OwnedValue, Self::BaseGraph, Self::Graph>

Sorts the by its values in ascending or descending order.

fn sort_by_id( &self, ) -> NodeState<'graph, Self::OwnedValue, Self::BaseGraph, Self::Graph>

Sort the results by global node id

fn top_k_by<F: Fn(&Self::OwnedValue, &Self::OwnedValue) -> Ordering + Sync>( &self, cmp: F, k: usize, ) -> NodeState<'graph, Self::OwnedValue, Self::BaseGraph, Self::Graph>

Retrieves the top-k elements from the AlgorithmResult based on its values.

fn bottom_k_by<F: Fn(&Self::OwnedValue, &Self::OwnedValue) -> Ordering + Sync>( &self, cmp: F, k: usize, ) -> NodeState<'graph, Self::OwnedValue, Self::BaseGraph, Self::Graph>

fn min_item_by<F: Fn(&Self::OwnedValue, &Self::OwnedValue) -> Ordering + Sync>( &self, cmp: F, ) -> Option<(NodeView<'_, &Self::BaseGraph, &Self::Graph>, Self::Value<'_>)>

fn max_item_by<F: Fn(&Self::OwnedValue, &Self::OwnedValue) -> Ordering + Sync>( &self, cmp: F, ) -> Option<(NodeView<'_, &Self::BaseGraph, &Self::Graph>, Self::Value<'_>)>

fn median_item_by<F: Fn(&Self::OwnedValue, &Self::OwnedValue) -> Ordering + Sync>( &self, cmp: F, ) -> Option<(NodeView<'_, &Self::BaseGraph, &Self::Graph>, Self::Value<'_>)>

fn group_by<V: Hash + Eq + Send + Sync + Clone + Debug, F: Fn(&Self::OwnedValue) -> V + Sync>( &self, group_fn: F, ) -> NodeGroups<V, Self::Graph>

fn sum<'a, S>(&'a self) -> S

where S: Send + Sum<Self::Value<'a>> + Sum<S>, 'graph: 'a,

fn mean<'a>(&'a self) -> f64

where Self::OwnedValue: Sum<Self::Value<'a>> + Sum + AsPrimitive<f64>, 'graph: 'a,

impl<'graph, RHS: Send + Sync, V: PartialEq<RHS> + Send + Sync + Clone + 'graph, G, GH> PartialEq<&[RHS]> for NodeState<'graph, V, G, GH>

fn eq(&self, other: &&[RHS]) -> 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<'graph, K: AsNodeRef, RHS: Send + Sync, V: PartialEq<RHS> + Send + Sync + Clone + 'graph, G: GraphViewOps<'graph>, GH: GraphViewOps<'graph>, S> PartialEq<HashMap<K, RHS, S>> for NodeState<'graph, V, G, GH>

fn eq(&self, other: &HashMap<K, RHS, S>) -> 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<'graph, V: Clone + Send + Sync + PartialEq + 'graph, G: GraphViewOps<'graph>, GH: GraphViewOps<'graph>, RHS: NodeStateOps<'graph, OwnedValue = V>> PartialEq<RHS> for NodeState<'graph, V, G, GH>

fn eq(&self, other: &RHS) -> 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<'graph, RHS: Send + Sync, V: PartialEq<RHS> + Send + Sync + Clone + 'graph, G, GH> PartialEq<Vec<RHS>> for NodeState<'graph, V, G, GH>

fn eq(&self, other: &Vec<RHS>) -> 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.