Struct GraphTransaction 

pub struct GraphTransaction {
    pub label: Option<String>,
    pub ops: Vec<GraphOp>,
}

A batch of edit operations that should be applied and undone as one unit.

Fields

label: Option<String>

Optional human-readable label for history UI.

ops: Vec<GraphOp>

Operations in order.

Implementations

impl GraphTransaction

pub fn new() -> Self

Creates an empty transaction.

Examples found in repository

examples/build_graph.rs (line 36)

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 from_ops(ops: impl IntoIterator<Item = GraphOp>) -> Self

Creates an unlabeled transaction from ops.

pub fn from_parts( label: Option<String>, ops: impl IntoIterator<Item = GraphOp>, ) -> Self

Creates a transaction from metadata and ops.

pub fn diff(from: &Graph, to: &Graph) -> Self

Builds a deterministic transaction that transforms from into to.

pub fn with_label(self, label: impl Into<String>) -> Self

Sets a label.

Examples found in repository

examples/build_graph.rs (line 36)

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 with_optional_label(self, label: Option<String>) -> Self

Sets or clears the optional label.

pub fn with_ops(self, ops: impl IntoIterator<Item = GraphOp>) -> Self

Adds ops in order and returns this transaction.

pub fn map_ops(self, f: impl FnOnce(Vec<GraphOp>) -> Vec<GraphOp>) -> Self

Transforms this transaction’s ops while preserving metadata.

pub fn push(&mut self, op: GraphOp)

Pushes an op.

Examples found in repository

examples/build_graph.rs (lines 37-40)

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 extend(&mut self, ops: impl IntoIterator<Item = GraphOp>)

Extends this transaction with ops in order.

pub fn retain_ops(&mut self, f: impl FnMut(&GraphOp) -> bool)

Retains ops that match f.

pub fn clear_ops(&mut self)

Removes all ops while preserving transaction metadata.

pub fn is_empty(&self) -> bool

pub fn label(&self) -> Option<&str>

Returns the optional human-readable label.

pub fn ops(&self) -> &[GraphOp]

Returns ops in order.

pub fn into_ops(self) -> Vec<GraphOp>

Consumes this transaction and returns its ops in order.

pub fn into_parts(self) -> (Option<String>, Vec<GraphOp>)

Consumes this transaction and returns its metadata and ops.

pub fn len(&self) -> usize

Returns the number of ops.

pub fn apply_to(&self, graph: &mut Graph) -> Result<(), ApplyError>

Applies this transaction atomically to graph.

Examples found in repository

examples/build_graph.rs (line 41)

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 inverse(&self) -> Self

Builds the inverse transaction for undo/redo.

impl GraphTransaction

pub fn footprint(&self) -> GraphMutationFootprint

Returns the graph-local ids touched by all operations in this transaction.

pub fn append_footprint(&self, footprint: &mut GraphMutationFootprint)

Appends this transaction’s touched ids to an existing footprint.

Trait Implementations

impl Clone for GraphTransaction

fn clone(&self) -> GraphTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphTransaction

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

Formats the value using the given formatter.

impl Default for GraphTransaction

fn default() -> GraphTransaction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GraphTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GraphTransaction

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

where __S: Serializer,

Serialize this value into the given Serde serializer.