Struct Rerooted

pub struct Rerooted<H: HugrView> { /* private fields */ }

A HUGR wrapper with a modified entrypoint node.

All nodes from the original are still present, but the main entrypoint used for traversals and optimizations is altered.

Implementations

impl<H: HugrView> Rerooted<H>

pub fn new(hugr: H, entrypoint: H::Node) -> Self

Create a hierarchical view of a whole HUGR

Panics

If the new entrypoint is not in the HUGR.

pub fn into_unwrapped(self) -> H

Returns the HUGR wrapped in this view.

Trait Implementations

impl<H: Clone + HugrView> Clone for Rerooted<H>

where H::Node: Clone,

fn clone(&self) -> Rerooted<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H: HugrView> HugrInternals for Rerooted<H>

type RegionPortgraph<'p> = <H as HugrInternals>::RegionPortgraph<'p> where Self: 'p

The portgraph graph structure returned by HugrInternals::region_portgraph.

type Node = <H as HugrInternals>::Node

The type of nodes in the Hugr.

type RegionPortgraphNodes = <H as HugrInternals>::RegionPortgraphNodes

A mapping between HUGR nodes and portgraph nodes in the graph returned by HugrInternals::region_portgraph.

fn region_portgraph( &self, parent: Self::Node, ) -> (FlatRegion<'_, Self::RegionPortgraph<'_>>, Self::RegionPortgraphNodes)

Returns a flat portgraph view of a region in the HUGR, and a mapping between HUGR nodes and portgraph nodes in the graph.

fn node_metadata_map(&self, node: Self::Node) -> &NodeMetadataMap

Returns a metadata entry associated with a node.

impl<H: HugrMut> HugrMut for Rerooted<H>

fn set_entrypoint(&mut self, root: Self::Node)

Set entrypoint to the HUGR.

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

Returns a metadata entry associated with a node.

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

Sets a metadata value associated with a node.

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

Remove a metadata entry associated with a node.

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

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

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

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

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

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

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

fn remove_subtree(&mut self, node: Self::Node)

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

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

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

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

Connect two nodes at the given ports.

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

Disconnects all edges from the given port.

fn add_other_edge( &mut self, src: Self::Node, dst: Self::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: Self::Node, other: Hugr, ) -> InsertionResult<Node, Self::Node>

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

fn insert_region( &mut self, root: Self::Node, other: Hugr, region: Node, ) -> InsertionResult<Node, Self::Node>

Insert a sub-region of another hugr into this one, under a given parent node.

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

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

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

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

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.

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.

fn with_entrypoint_mut(&mut self, entrypoint: Self::Node) -> Rerooted<&mut Self>

where Self: Sized,

Returns a mutable view of the HUGR with a different entrypoint.

fn apply_patch<R, E>( &mut self, rw: impl Patch<Self, Outcome = R, Error = E>, ) -> Result<R, E>

where Self: Sized,

Applies a patch to the graph.

impl<H: HugrMutInternals> HugrMutInternals for Rerooted<H>

fn set_module_root(&mut self, root: Self::Node)

Set the node at the root of the HUGR hierarchy.

fn set_num_ports(&mut self, node: Self::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: Self::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 insert_ports( &mut self, node: Self::Node, direction: Direction, index: usize, amount: usize, ) -> Range<usize>

Insert amount new ports for a node, starting at index. The direction parameter specifies whether to add ports to the incoming or outgoing list. Links from this node are preserved, even when ports are renumbered by the insertion.

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

Sets the parent of a node.

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

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

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

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

fn replace_op(&mut self, node: Self::Node, op: impl Into<OpType>) -> OpType

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.

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

Gets a mutable reference to the optype.

fn node_metadata_map_mut(&mut self, node: Self::Node) -> &mut NodeMetadataMap

Returns a metadata entry associated with a node.

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

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

impl<H: HugrView> HugrView for Rerooted<H>

fn entrypoint(&self) -> Self::Node

The distinguished node from where operations are applied, commonly defining a region of interest.

fn entrypoint_optype(&self) -> &OpType

Returns the operation type of the entrypoint node.

fn mermaid_string_with_formatter( &self, formatter: MermaidFormatter<'_, Self>, ) -> String

Return the mermaid representation of the underlying hierarchical graph according to the provided MermaidFormatter formatting options.

fn module_root(&self) -> Self::Node

A pointer to the module region defined at the root of the HUGR.

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

Returns true if the node exists in the HUGR.

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

Returns the parent of a node.

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

Returns the metadata associated with a node.

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

Returns the operation type of a node.

fn num_nodes(&self) -> usize

Returns the number of nodes in the HUGR.

fn num_edges(&self) -> usize

Returns the number of edges in the HUGR.

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

Number of ports in node for a given direction.

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

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

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

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

fn nodes(&self) -> impl Iterator<Item = Self::Node> + Clone

Iterates over the all the nodes in the HUGR.

fn node_ports( &self, node: Self::Node, dir: Direction, ) -> impl Iterator<Item = Port> + Clone

Iterator over ports of node in a given direction.

fn node_outputs( &self, node: Self::Node, ) -> impl Iterator<Item = OutgoingPort> + Clone

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: Self::Node, ) -> impl Iterator<Item = IncomingPort> + Clone

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

fn all_node_ports(&self, node: Self::Node) -> impl Iterator<Item = Port> + Clone

Iterator over both the input and output ports of node.

fn linked_ports( &self, node: Self::Node, port: impl Into<Port>, ) -> impl Iterator<Item = (Self::Node, Port)> + Clone

Iterator over the nodes and ports connected to a port.

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

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

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

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

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

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

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

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

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

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

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

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

fn linked_outputs( &self, node: Self::Node, port: impl Into<IncomingPort>, ) -> impl Iterator<Item = (Self::Node, OutgoingPort)>

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: Self::Node, port: impl Into<OutgoingPort>, ) -> impl Iterator<Item = (Self::Node, IncomingPort)>

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 node_connections( &self, node: Self::Node, other: Self::Node, ) -> impl Iterator<Item = [Port; 2]> + Clone

Iterator the links between two nodes.

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

Returns whether a port is connected.

fn children( &self, node: Self::Node, ) -> impl DoubleEndedIterator<Item = Self::Node> + Clone

Returns an iterator over the direct children of node.

fn descendants( &self, node: Self::Node, ) -> impl Iterator<Item = Self::Node> + Clone

Returns an iterator over all the descendants of a node, including the node itself.

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

Returns the first child of the specified node (if it is a parent). Useful because x.children().next() leaves x borrowed.

fn neighbours( &self, node: Self::Node, dir: Direction, ) -> impl Iterator<Item = Self::Node> + Clone

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

fn all_neighbours( &self, node: Self::Node, ) -> impl Iterator<Item = Self::Node> + Clone

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

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

👎Deprecated: Use mermaid_format instead

Return the mermaid representation of the underlying hierarchical graph.

fn dot_string(&self) -> String

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

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

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

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

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

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

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

fn extensions(&self) -> &ExtensionRegistry

Returns the set of extensions used by the HUGR.

fn validate(&self) -> Result<(), ValidationError<Self::Node>>

Check the validity of the underlying HUGR.

fn extract_hugr( &self, parent: Self::Node, ) -> (Hugr, impl ExtractionResult<Self::Node> + 'static)

Extracts a HUGR containing the parent node and all its descendants.

fn entrypoint_tag(&self) -> OpTag

An operation tag that is guaranteed to represent the HugrView::entrypoint node operation.

fn with_entrypoint(&self, entrypoint: Self::Node) -> Rerooted<&Self>

where Self: Sized,

Returns a non-mutable view of the HUGR with a different entrypoint.

fn entry_descendants(&self) -> impl Iterator<Item = Self::Node> + Clone

Returns an iterator over all the descendants of the hugr entrypoint, including the node itself.

fn input_neighbours( &self, node: Self::Node, ) -> impl Iterator<Item = Self::Node> + Clone

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

fn output_neighbours( &self, node: Self::Node, ) -> impl Iterator<Item = Self::Node> + Clone

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

fn get_io(&self, node: Self::Node) -> Option<[Self::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 inner_function_type(&self) -> Option<Cow<'_, Signature>>

Returns the function type defined by this dataflow HUGR.

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

Returns the function type defined by this HUGR, i.e. Some iff the root is a FuncDecl or FuncDefn.

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_format(&self) -> MermaidFormatter<'_, Self>

Construct a mermaid representation of the underlying hierarchical graph.

fn signature(&self, node: Self::Node) -> Option<Cow<'_, Signature>>

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

fn in_value_types( &self, node: Self::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: Self::Node, ) -> impl Iterator<Item = (OutgoingPort, Type)>

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