Trait HugrMut

pub trait HugrMut: HugrMutInternals {
    // Provided methods
    fn get_metadata_mut(
        &mut self,
        node: Node,
        key: impl AsRef<str>,
    ) -> &mut NodeMetadata { ... }
    fn set_metadata(
        &mut self,
        node: Node,
        key: impl AsRef<str>,
        metadata: impl Into<NodeMetadata>,
    ) { ... }
    fn remove_metadata(&mut self, node: Node, key: impl AsRef<str>) { ... }
    fn take_node_metadata(
        &mut self,
        node: Self::Node,
    ) -> Option<NodeMetadataMap> { ... }
    fn overwrite_node_metadata(
        &mut self,
        node: Node,
        metadata: Option<NodeMetadataMap>,
    ) { ... }
    fn add_node_with_parent(
        &mut self,
        parent: Node,
        op: impl Into<OpType>,
    ) -> Node { ... }
    fn add_node_before(
        &mut self,
        sibling: Node,
        nodetype: impl Into<OpType>,
    ) -> Node { ... }
    fn add_node_after(&mut self, sibling: Node, op: impl Into<OpType>) -> Node { ... }
    fn remove_node(&mut self, node: Node) -> OpType { ... }
    fn remove_subtree(&mut self, node: Node) { ... }
    fn copy_descendants(
        &mut self,
        root: Node,
        new_parent: Node,
        subst: Option<Substitution<'_>>,
    ) -> BTreeMap<Node, Node> { ... }
    fn connect(
        &mut self,
        src: Node,
        src_port: impl Into<OutgoingPort>,
        dst: Node,
        dst_port: impl Into<IncomingPort>,
    ) { ... }
    fn disconnect(&mut self, node: Node, port: impl Into<Port>) { ... }
    fn add_other_edge(
        &mut self,
        src: Node,
        dst: Node,
    ) -> (OutgoingPort, IncomingPort) { ... }
    fn insert_hugr(&mut self, root: Node, other: Hugr) -> InsertionResult { ... }
    fn insert_from_view(
        &mut self,
        root: Node,
        other: &impl HugrView,
    ) -> InsertionResult { ... }
    fn insert_subgraph(
        &mut self,
        root: Node,
        other: &impl HugrView,
        subgraph: &SiblingSubgraph,
    ) -> HashMap<Node, Node> { ... }
    fn apply_rewrite<R, E>(
        &mut self,
        rw: impl Rewrite<ApplyResult = R, Error = E>,
    ) -> Result<R, E>
       where Self: Sized { ... }
    fn use_extension(&mut self, extension: impl Into<Arc<Extension>>) { ... }
    fn use_extensions<Reg>(&mut self, registry: impl IntoIterator<Item = Reg>)
       where ExtensionRegistry: Extend<Reg> { ... }
    fn extensions_mut(&mut self) -> &mut ExtensionRegistry { ... }
}

Functions for low-level building of a HUGR.

Provided Methods

fn get_metadata_mut( &mut self, node: Node, key: impl AsRef<str>, ) -> &mut NodeMetadata

Returns a metadata entry associated with a node.

Panics

If the node is not in the graph.

fn set_metadata( &mut self, node: Node, key: impl AsRef<str>, metadata: impl Into<NodeMetadata>, )

Sets a metadata value associated with a node.

Panics

If the node is not in the graph.

fn remove_metadata(&mut self, node: Node, key: impl AsRef<str>)

Remove a metadata entry associated with a node.

Panics

If the node is not in the graph.

fn take_node_metadata(&mut self, node: Self::Node) -> Option<NodeMetadataMap>

Retrieve the complete metadata map for a node.

fn overwrite_node_metadata( &mut self, node: Node, metadata: Option<NodeMetadataMap>, )

Overwrite the complete metadata map for a node.

Panics

If the node is not in the graph.

fn add_node_with_parent(&mut self, parent: Node, op: impl Into<OpType>) -> Node

Add a node to the graph with a parent in the hierarchy.

The node becomes the parent’s last child.

Panics

If the parent is not in the graph.

fn add_node_before( &mut self, sibling: Node, nodetype: impl Into<OpType>, ) -> Node

Add a node to the graph as the previous sibling of another node.

The sibling node’s parent becomes the new node’s parent.

Panics

If the sibling is not in the graph, or if the sibling is the root node.

fn add_node_after(&mut self, sibling: Node, op: impl Into<OpType>) -> Node

Add a node to the graph as the next sibling of another node.

The sibling node’s parent becomes the new node’s parent.

Panics

If the sibling is not in the graph, or if the sibling is the root node.

fn remove_node(&mut self, node: Node) -> OpType

Remove a node from the graph and return the node weight. Note that if the node has children, they are not removed; this leaves the Hugr in an invalid state. See Self::remove_subtree.

Panics

If the node is not in the graph, or if the node is the root node.

fn remove_subtree(&mut self, node: Node)

Remove a node from the graph, along with all its descendants in the hierarchy.

Panics

If the node is not in the graph, or is the root (this would leave an empty Hugr).

fn copy_descendants( &mut self, root: Node, new_parent: Node, subst: Option<Substitution<'_>>, ) -> BTreeMap<Node, Node>

Copies the strict descendants of root to under the new_parent, optionally applying a Substitution to the OpTypes of the copied nodes.

That is, the immediate children of root, are copied to make children of new_parent.

Note this may invalidate the Hugr in two ways:

• Adding children of root may make the children-list of new_parent invalid e.g. leading to multiple Input, Output or ExitBlock nodes or Input/Output in the wrong positions
• Nonlocal edges incoming to the subtree of root will be copied to target the subtree under new_parent which may be invalid if new_parent is not a child of roots parent (for Ext edges - or correspondingly for Dom edges)

fn connect( &mut self, src: Node, src_port: impl Into<OutgoingPort>, dst: Node, dst_port: impl Into<IncomingPort>, )

Connect two nodes at the given ports.

Panics

If either node is not in the graph or if the ports are invalid.

fn disconnect(&mut self, node: Node, port: impl Into<Port>)

Disconnects all edges from the given port.

The port is left in place.

Panics

If the node is not in the graph, or if the port is invalid.

fn add_other_edge( &mut self, src: Node, dst: Node, ) -> (OutgoingPort, IncomingPort)

Adds a non-dataflow edge between two nodes. The kind is given by the operation’s OpTrait::other_input or OpTrait::other_output.

Returns the offsets of the new input and output ports.

Panics

If the node is not in the graph, or if the port is invalid.

fn insert_hugr(&mut self, root: Node, other: Hugr) -> InsertionResult

Insert another hugr into this one, under a given root node.

Panics

If the root node is not in the graph.

fn insert_from_view( &mut self, root: Node, other: &impl HugrView, ) -> InsertionResult

Copy another hugr into this one, under a given root node.

Panics

If the root node is not in the graph.

fn insert_subgraph( &mut self, root: Node, other: &impl HugrView, subgraph: &SiblingSubgraph, ) -> HashMap<Node, Node>

Copy a subgraph from another hugr into this one, under a given root node.

Sibling order is not preserved.

The return value is a map from indices in other to the indices of the corresponding new nodes in self.

Panics

If the root node is not in the graph.

fn apply_rewrite<R, E>( &mut self, rw: impl Rewrite<ApplyResult = R, Error = E>, ) -> Result<R, E>

where Self: Sized,

Applies a rewrite to the graph.

fn use_extension(&mut self, extension: impl Into<Arc<Extension>>)

Registers a new extension in the set used by the hugr, keeping the one most recent one if the extension already exists.

These can be queried using HugrView::extensions.

See ExtensionRegistry::register_updated for more information.

fn use_extensions<Reg>(&mut self, registry: impl IntoIterator<Item = Reg>)

where ExtensionRegistry: Extend<Reg>,

Extend the set of extensions used by the hugr with the extensions in the registry.

For each extension, keeps the most recent version if the id already exists.

These can be queried using HugrView::extensions.

See ExtensionRegistry::register_updated for more information.

fn extensions_mut(&mut self) -> &mut ExtensionRegistry

Returns a mutable reference to the extension registry for this hugr.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<H: HugrMutInternals + AsRef<Hugr>, Root: NodeHandle> HugrMut for RootChecked<H, Root>

impl<Root: NodeHandle> HugrMut for SiblingMut<'_, Root>

impl<T: RootTagged<RootHandle = Node, Node = Node> + AsMut<Hugr>> HugrMut for T

Impl for non-wrapped Hugrs. Overwrites the recursive default-impls to directly use the hugr.