Struct GraphDiff

pub struct GraphDiff<Id: Hash + Eq + Copy, T: Default + AddAssign, W = f32> { /* private fields */ }

A differential between two graphs.

Contains a diff for the nodes and edges of a graph. Each diff contains new or updated items and items that are marked for deletion. The diff will always be internally consistent if the safe, public methods are used.

GraphDiff requires two generic types:

• Id is the type used to index nodes in the graph. It requires standard trait bounds for index types.
• T is the type used to represent node property updates. It requires Default used when adding a new node to the diff and AddAssign to combine updates.

GraphDiffs support composition with AddAssign:

use drisk_api::GraphDiff;

let mut diff1: GraphDiff<u32, u32> = GraphDiff::default();
let diff2: GraphDiff<u32, u32> = GraphDiff::default();

// `diff1` will contain all nodes and edges from `diff2`.
// If a node or edge is updated in both, the updates will be combined.
// Updates to the same properties from `diff2` will overwrite updates from `diff1`.
// If a node is deleted in `diff2`, it will be deleted in the combined diff.
diff1 += diff2;

Implementations

impl<Id: Hash + Eq + Copy, T: Default + AddAssign, W: Copy + PartialEq> GraphDiff<Id, T, W>

pub fn new() -> GraphDiff<Id, T>

pub fn from_diffs( nodes: NodeDiff<Id, T>, edges: EdgeDiff<Id, W>, ) -> GraphDiff<Id, T, W>

Initialse diff from a NodeDiff and an EdgeDiff

pub fn nodes(&self) -> &NodeDiff<Id, T>

Get a reference to the node diff.

pub fn new_or_updated_nodes(&self) -> &HashMap<Id, T>

Get a reference to the new or updated nodes.

pub fn deleted_nodes(&self) -> &HashSet<Id>

Get a reference to the deleted nodes.

pub fn edges(&self) -> &EdgeDiff<Id, W>

Get a reference to the edge diff.

pub fn new_or_updated_edges(&self) -> &HashMap<Id, HashMap<Id, W>>

Get a reference to the new or updated edges.

pub fn deleted_edges(&self) -> &HashMap<Id, HashSet<Id>>

Get a reference to the deleted edges.

pub fn is_empty(&self) -> bool

Returns true if the diff contains no nodes or edges (new, updated or deleted).

pub fn add_node(&mut self, node_id: &Id)

Add a new node to the diff. If previously marked as deleted, it will be overwritten.

pub fn add_or_update_node(&mut self, node_id: &Id, update: T)

Add or update a node in the diff with an update. If previously marked as deleted, it will be overwritten

pub fn get_or_create_mut_node_update(&mut self, node_id: &Id) -> &mut T

Get a mutable reference to a node update in the diff. If the node is not present, it will be added with an empty update.

pub fn set_node_update(&mut self, node_id: &Id, update: T)

Use with caution: overwrites the node update to whatever you provide.

pub fn delete_node(&mut self, node_id: Id)

Add a new node to be deleted to the diff. If present the node will be removed from new_or_updated. It further updates the edge diff to make sure an edge deletion is recorded for all edges connecting to the node.

pub fn add_edge( &mut self, from: &Id, to: &Id, weight: W, ) -> Result<(), Box<dyn Error>>

Add a new edge to the diff. If previously marked as deleted, it will be overwritten If either the from or to nodes are marked as deleted, it will error.

pub fn add_edges( &mut self, edges: &HashMap<Id, HashMap<Id, W>>, ) -> Result<(), Box<dyn Error>>

Add edges in batch to the dif.

pub fn delete_edges( &mut self, edges: &HashMap<Id, HashSet<Id>>, ) -> Result<(), Box<dyn Error>>

Delete edges in batch from the diff.

pub unsafe fn add_edges_unchecked( &mut self, edges: HashMap<Id, HashMap<Id, W>>, ) -> Result<(), Box<dyn Error>>

Safety

Does not check that the node IDs are valid (i.e. not marked as deleted).

pub fn delete_edge(&mut self, from: &Id, to: &Id)

Add a new edge to be deleted to the diff. If present, the edge is removed from new_or_updated.

pub fn clear(&mut self)

Clear the diff of all nodes and edges.

Trait Implementations

impl<Id: Hash + Eq + Copy, T: Default + AddAssign> AddAssign<EdgeDiff<Id>> for GraphDiff<Id, T>

fn add_assign(&mut self, edges: EdgeDiff<Id>)

Performs the += operation.

impl<Id: Hash + Eq + Copy, T: Default + AddAssign> AddAssign<NodeDiff<Id, T>> for GraphDiff<Id, T>

fn add_assign(&mut self, nodes: NodeDiff<Id, T>)

Performs the += operation.

impl<Id: Hash + Eq + Copy, T: Default + AddAssign> AddAssign for GraphDiff<Id, T>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<Id: Clone + Hash + Eq + Copy, T: Clone + Default + AddAssign, W: Clone> Clone for GraphDiff<Id, T, W>

fn clone(&self) -> GraphDiff<Id, T, W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Id: Debug + Hash + Eq + Copy, T: Debug + Default + AddAssign, W: Debug> Debug for GraphDiff<Id, T, W>

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

Formats the value using the given formatter.

impl<Id: Hash + Eq + Copy, T: Default + AddAssign> Default for GraphDiff<Id, T>

fn default() -> GraphDiff<Id, T>

Returns the “default value” for a type.

impl<'de, Id, T, W> Deserialize<'de> for GraphDiff<Id, T, W>

where Id: Deserialize<'de> + Hash + Eq + Copy, T: Deserialize<'de> + Default + AddAssign, W: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Id: PartialEq + Hash + Eq + Copy, T: PartialEq + Default + AddAssign, W: PartialEq> PartialEq for GraphDiff<Id, T, W>

fn eq(&self, other: &GraphDiff<Id, T, W>) -> 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<Id, T, W> Serialize for GraphDiff<Id, T, W>

where Id: Serialize + Hash + Eq + Copy, T: Serialize + Default + AddAssign, W: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Id: Hash + Eq + Copy, T: Default + AddAssign, W> StructuralPartialEq for GraphDiff<Id, T, W>