Struct hugr_core::hugr::views::sibling::SiblingMut

pub struct SiblingMut<'g, Root = Node> { /* private fields */ }

Mutable view onto a HUGR sibling graph.

Like SiblingGraph, includes only the root node and its direct children, but no deeper descendants; but the descendants can still be accessed by creating nested SiblingMut instances from nodes in the view.

Uniquely, the root node has no parent.

HugrView methods may be slower than for an immutable SiblingGraph as the latter may cache information about the graph connectivity, whereas (in order to ease mutation) this does not.

Implementations

impl<'g, Root: NodeHandle> SiblingMut<'g, Root>

pub fn try_new<Base: HugrMut>( hugr: &'g mut Base, root: Node, ) -> Result<Self, HugrError>

Create a new SiblingMut from a base. Equivalent to HierarchyView::try_new but takes a mutable reference.

Trait Implementations

impl<'g, Root: NodeHandle> ExtractHugr for SiblingMut<'g, Root>

fn extract_hugr(self) -> Hugr

Extracts the view into an owned HUGR, rooted at the view’s root node and containing only the nodes and edges of the view.

impl<'g, Root: NodeHandle> HugrInternals for SiblingMut<'g, Root>

type Portgraph<'p> = FilteredGraph<&'p MultiPortGraph, fn(_: NodeIndex, _: &(&'p Hierarchy, NodeIndex)) -> bool, fn(_: PortIndex, _: &(&'p Hierarchy, NodeIndex)) -> bool, (&'p Hierarchy, NodeIndex)> where Root: 'p, 'g: 'p

The underlying portgraph view type.

fn portgraph(&self) -> Self::Portgraph<'_>

Returns a reference to the underlying portgraph.

fn base_hugr(&self) -> &Hugr

Returns the Hugr at the base of a chain of views.

fn root_node(&self) -> Node

Return the root node of this view.

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

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

Returns a metadata entry associated with a node.

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

Sets a metadata value associated with a node.

fn take_node_metadata(&mut self, node: 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.

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

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

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

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

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

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

fn remove_node(&mut self, node: Node)

Remove a node from the graph.

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.

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

Disconnects all edges from the given port.

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.

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

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

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

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

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.

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.

impl<'g, Root: NodeHandle> HugrMutInternals for SiblingMut<'g, Root>

fn hugr_mut(&mut self) -> &mut Hugr

Returns the Hugr at the base of a chain of views.

fn set_num_ports(&mut self, node: Node, incoming: usize, outgoing: usize)

Set the number of ports on a node. This may invalidate the node’s PortIndex.

fn add_ports( &mut self, node: Node, direction: Direction, amount: isize, ) -> Range<usize>

Alter the number of ports on a node and returns a range with the new port offsets, if any. This may invalidate the node’s PortIndex.

fn set_parent(&mut self, node: Node, parent: Node)

Sets the parent of a node.

fn move_after_sibling(&mut self, node: Node, after: Node)

Move a node in the hierarchy to be the subsequent sibling of another node.

fn move_before_sibling(&mut self, node: Node, before: Node)

Move a node in the hierarchy to be the prior sibling of another node.

fn replace_op( &mut self, node: Node, op: NodeType, ) -> Result<NodeType, HugrError>

Replace the OpType at node and return the old OpType. In general this invalidates the ports, which may need to be resized to match the OpType signature. TODO: Add a version which ignores input extensions

impl<'g, Root: NodeHandle> HugrView for SiblingMut<'g, Root>

type Neighbours<'a> = <Vec<Node> as IntoIterator>::IntoIter where Self: 'a

An Iterator over (some or all) the nodes neighbouring a node

type PortLinks<'a> = <Vec<(Node, Port)> as IntoIterator>::IntoIter where Self: 'a

Iterator over the children of a node

type NodeConnections<'a> = <Vec<[Port; 2]> as IntoIterator>::IntoIter where Self: 'a

Iterator over the links between two nodes.

type Nodes<'a> = Chain<Once<Node>, MapSpecialCase<Children<'a>, MapSpecialCaseFnInto<Node>>> where Self: 'a

An Iterator over the nodes in a Hugr(View)

type NodePorts<'a> = MapSpecialCase<<FilteredGraph<&'g MultiPortGraph, fn(_: NodeIndex, _: &(&'g Hierarchy, NodeIndex)) -> bool, fn(_: PortIndex, _: &(&'g Hierarchy, NodeIndex)) -> bool, (&'g Hierarchy, NodeIndex)> as PortView>::NodePortOffsets<'a>, MapSpecialCaseFnInto<Port>> where Self: 'a

An Iterator over (some or all) ports of a node

type Children<'a> = MapSpecialCase<Children<'a>, MapSpecialCaseFnInto<Node>> where Self: 'a

An Iterator over the children of a node

fn node_count(&self) -> usize

Returns the number of nodes in the hugr.

fn edge_count(&self) -> usize

Returns the number of edges in the hugr.

fn nodes(&self) -> Self::Nodes<'_>

Iterates over the nodes in the port graph.

fn children(&self, node: Node) -> Self::Children<'_>

Return iterator over the direct children of node.

fn contains_node(&self, node: Node) -> bool

Returns whether the node exists.

fn node_ports(&self, node: Node, dir: Direction) -> Self::NodePorts<'_>

Iterator over ports of node in a given direction.

fn all_node_ports(&self, node: Node) -> Self::NodePorts<'_>

Iterator over both the input and output ports of node.

fn linked_ports(&self, node: Node, port: impl Into<Port>) -> Self::PortLinks<'_>

Iterator over the nodes and ports connected to a port.

fn node_connections(&self, node: Node, other: Node) -> Self::NodeConnections<'_>

Iterator the links between two nodes.

fn num_ports(&self, node: Node, dir: Direction) -> usize

Number of ports in node for a given direction.

fn neighbours(&self, node: Node, dir: Direction) -> Self::Neighbours<'_>

Iterates over neighbour nodes in the given direction. May contain duplicates if the graph has multiple links between nodes.

fn all_neighbours(&self, node: Node) -> Self::Neighbours<'_>

Iterates over the input and output neighbours of the node in sequence.

fn root(&self) -> Node

Return the root node of this view.

fn root_type(&self) -> &NodeType

Return the type of the HUGR root node.

fn valid_node(&self, node: Node) -> bool

Validates that a node is valid in the graph.

fn valid_non_root(&self, node: Node) -> bool

Validates that a node is a valid root descendant in the graph.

fn get_parent(&self, node: Node) -> Option<Node>

Returns the parent of a node.

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

Returns the operation type of a node.

fn get_nodetype(&self, node: Node) -> &NodeType

Returns the type of a node.

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

Returns the metadata associated with a node.

fn get_node_metadata(&self, node: Node) -> Option<&NodeMetadataMap>

Retrieve the complete metadata map for a node.

fn node_outputs(&self, node: Node) -> OutgoingPorts<Self::NodePorts<'_>>

Iterator over output ports of node. Like node_ports(node, Direction::Outgoing) but preserves knowledge that the ports are OutgoingPorts.

fn node_inputs(&self, node: Node) -> IncomingPorts<Self::NodePorts<'_>>

Iterator over inputs ports of node. Like node_ports(node, Direction::Incoming) but preserves knowledge that the ports are IncomingPorts.

fn all_linked_ports( &self, node: Node, dir: Direction, ) -> Either<impl Iterator<Item = (Node, OutgoingPort)>, impl Iterator<Item = (Node, IncomingPort)>>

Iterator over all the nodes and ports connected to a node in a given direction.

fn all_linked_outputs( &self, node: Node, ) -> impl Iterator<Item = (Node, OutgoingPort)>

Iterator over all the nodes and ports connected to a node’s inputs.

fn all_linked_inputs( &self, node: Node, ) -> impl Iterator<Item = (Node, IncomingPort)>

Iterator over all the nodes and ports connected to a node’s outputs.

fn single_linked_port( &self, node: Node, port: impl Into<Port>, ) -> Option<(Node, Port)>

If there is exactly one port connected to this port, return it and its node.

fn single_linked_output( &self, node: Node, port: impl Into<IncomingPort>, ) -> Option<(Node, OutgoingPort)>

If there is exactly one OutgoingPort connected to this IncomingPort, return it and its node.

fn single_linked_input( &self, node: Node, port: impl Into<OutgoingPort>, ) -> Option<(Node, IncomingPort)>

If there is exactly one IncomingPort connected to this OutgoingPort, return it and its node.

fn linked_outputs( &self, node: Node, port: impl Into<IncomingPort>, ) -> OutgoingNodePorts<Self::PortLinks<'_>>

Iterator over the nodes and output ports connected to a given input port. Like linked_ports but preserves knowledge that the linked ports are OutgoingPorts.

fn linked_inputs( &self, node: Node, port: impl Into<OutgoingPort>, ) -> IncomingNodePorts<Self::PortLinks<'_>>

Iterator over the nodes and input ports connected to a given output port Like linked_ports but preserves knowledge that the linked ports are IncomingPorts.

fn is_linked(&self, node: Node, port: impl Into<Port>) -> bool

Returns whether a port is connected.

fn num_inputs(&self, node: Node) -> usize

Number of inputs to a node. Shorthand for num_ports(node, Direction::Incoming).

fn num_outputs(&self, node: Node) -> usize

Number of outputs from a node. Shorthand for num_ports(node, Direction::Outgoing).

fn input_neighbours(&self, node: Node) -> Self::Neighbours<'_>

Iterates over the input neighbours of the node. Shorthand for neighbours(node, Direction::Incoming).

fn output_neighbours(&self, node: Node) -> Self::Neighbours<'_>

Iterates over the output neighbours of the node. Shorthand for neighbours(node, Direction::Outgoing).

fn get_io(&self, node: Node) -> Option<[Node; 2]>

Get the input and output child nodes of a dataflow parent. If the node isn’t a dataflow parent, then return None

fn get_df_function_type(&self) -> Option<FunctionType>

Returns the function type defined by this dataflow HUGR.

fn get_function_type(&self) -> Option<PolyFuncType>

Returns the function type defined by this HUGR.

fn as_petgraph(&self) -> PetgraphWrapper<'_, Self>

where Self: Sized,

Return a wrapper over the view that can be used in petgraph algorithms.

fn mermaid_string(&self) -> String

Return the mermaid representation of the underlying hierarchical graph.

fn mermaid_string_with_config(&self, config: RenderConfig) -> String

Return the mermaid representation of the underlying hierarchical graph.

fn dot_string(&self) -> String

where Self: Sized,

Return the graphviz representation of the underlying graph and hierarchy side by side.

fn static_source(&self, node: Node) -> Option<Node>

If a node has a static input, return the source node.

fn static_targets( &self, node: Node, ) -> Option<impl Iterator<Item = (Node, IncomingPort)>>

If a node has a static output, return the targets.

fn signature(&self, node: Node) -> Option<FunctionType>

Get the “signature” (incoming and outgoing types) of a node, non-Value kind ports will be missing.

fn value_types( &self, node: Node, dir: Direction, ) -> impl Iterator<Item = (Port, Type)>

Iterator over all outgoing ports that have Value type, along with corresponding types.

fn in_value_types( &self, node: Node, ) -> impl Iterator<Item = (IncomingPort, Type)>

Iterator over all incoming ports that have Value type, along with corresponding types.

fn out_value_types( &self, node: Node, ) -> impl Iterator<Item = (OutgoingPort, Type)>

Iterator over all incoming ports that have Value type, along with corresponding types.

fn validate(&self, reg: &ExtensionRegistry) -> Result<(), ValidationError>

Check the validity of the underlying HUGR.

fn validate_no_extensions( &self, reg: &ExtensionRegistry, ) -> Result<(), ValidationError>

Check the validity of the underlying HUGR, but don’t check consistency of extension requirements between connected nodes or between parents and children.

impl<'g, Root: NodeHandle> RootTagged for SiblingMut<'g, Root>

type RootHandle = Root

The kind of handle that can be used to refer to the root node.