Struct RootChecked

pub struct RootChecked<H, Root = Node>(/* private fields */);

A view of the whole Hugr. (Just provides static checking of the type of the root node)

Implementations

impl<H: RootTagged + AsRef<Hugr>, Root: NodeHandle> RootChecked<H, Root>

pub fn try_new(hugr: H) -> Result<Self, HugrError>

Create a hierarchical view of a whole HUGR

Errors

Returns HugrError::InvalidTag if the root isn’t a node of the required OpTag

impl<Root> RootChecked<Hugr, Root>

pub fn into_hugr(self) -> Hugr

Extracts the underlying (owned) Hugr

impl<Root> RootChecked<&mut Hugr, Root>

pub fn borrow(&self) -> RootChecked<&Hugr, Root>

Allows immutably borrowing the underlying mutable reference

Trait Implementations

impl<H: AsRef<Hugr>, Root> AsRef<Hugr> for RootChecked<H, Root>

fn as_ref(&self) -> &Hugr

Converts this type into a shared reference of the (usually inferred) input type.

impl<H: Clone, Root: Clone> Clone for RootChecked<H, Root>

fn clone(&self) -> RootChecked<H, Root>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H: AsRef<Hugr>, Root> HugrInternals for RootChecked<H, Root>

type Portgraph<'p> = &'p MultiPortGraph where Self: '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<H: HugrMutInternals + AsRef<Hugr>, Root: NodeHandle> HugrMut for RootChecked<H, 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 remove_metadata(&mut self, node: Node, key: impl AsRef<str>)

Remove a metadata entry 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<OpType>) -> Node

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

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.

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.

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.

fn remove_subtree(&mut self, node: Node)

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

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.

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 extensions_mut(&mut self) -> &mut ExtensionRegistry

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

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

where Root: NodeHandle,

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 insert_ports( &mut self, node: 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: 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: impl Into<OpType>, ) -> Result<OpType, 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.

impl<H: AsRef<Hugr>, Root> HugrView for RootChecked<H, Root>

fn root(&self) -> Node

Return the root node of this view.

fn root_type(&self) -> &OpType

Return the type of the HUGR root node.

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

Returns whether the node exists.

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_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_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) -> impl Iterator<Item = Node> + Clone

Iterates over the nodes in the port graph.

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

Iterator over ports of node in a given direction.

fn node_outputs(&self, node: 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: 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: Node) -> impl Iterator<Item = Port> + Clone

Iterator over both the input and output ports of node.

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

Iterator over the nodes and ports connected to a port.

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>, ) -> impl Iterator<Item = (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: Node, port: impl Into<OutgoingPort>, ) -> impl Iterator<Item = (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: Node, other: Node, ) -> impl Iterator<Item = [Port; 2]> + Clone

Iterator the links between two nodes.

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

Returns whether a port is connected.

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

Number of ports in node for a given direction.

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 children(&self, node: Node) -> impl DoubleEndedIterator<Item = Node> + Clone

Return iterator over the direct children of node.

fn first_child(&self, node: Node) -> Option<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: Node, dir: Direction, ) -> impl Iterator<Item = Node> + Clone

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

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

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

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

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

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

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

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 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.

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

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<Cow<'_, Signature>>

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 extensions(&self) -> &ExtensionRegistry

Returns the set of extensions used by the HUGR.

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

Check the validity of the underlying HUGR.

fn validate_no_extensions(&self) -> 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.

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

where Self: Sized,

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

impl<H: AsRef<Hugr>, Root: NodeHandle> RootTagged for RootChecked<H, Root>

type RootHandle = Root

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