Struct DescendantsGraph

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

View of a HUGR descendants graph.

Includes the root node (which uniquely has no parent) and all its descendants.

See SiblingGraph for a view that includes only the root and its immediate children. Prefer using SiblingGraph when possible, as it is more efficient.

Implements the HierarchyView trait, as well as HugrView, it can be used interchangeably with SiblingGraph.

Trait Implementations

impl<'g, Root: Clone> Clone for DescendantsGraph<'g, Root>

fn clone(&self) -> DescendantsGraph<'g, Root>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'g, Root: NodeHandle> ExtractHugr for DescendantsGraph<'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<'a, Root> HierarchyView<'a> for DescendantsGraph<'a, Root>

where Root: NodeHandle,

fn try_new(hugr: &'a impl HugrView, root: Node) -> Result<Self, HugrError>

Create a hierarchical view of a HUGR given a root node.

impl<'g, Root> HugrInternals for DescendantsGraph<'g, Root>

where Root: NodeHandle,

type Portgraph<'p> = &'p FilteredGraph<&'g MultiPortGraph, fn(_: NodeIndex, _: &RegionContext<'g>) -> bool, fn(_: PortIndex, _: &RegionContext<'g>) -> bool, RegionContext<'g>> 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<'g, Root: NodeHandle> HugrView for DescendantsGraph<'g, Root>

type Nodes<'a> = MapSpecialCase<<FilteredGraph<&'g MultiPortGraph, fn(_: NodeIndex, _: &RegionContext<'g>) -> bool, fn(_: PortIndex, _: &RegionContext<'g>) -> bool, RegionContext<'g>> as PortView>::Nodes<'a>, MapSpecialCaseFnInto<Node>> where Self: 'a

An Iterator over the nodes in a Hugr(View)

type NodePorts<'a> = MapSpecialCase<<FilteredGraph<&'g MultiPortGraph, fn(_: NodeIndex, _: &RegionContext<'g>) -> bool, fn(_: PortIndex, _: &RegionContext<'g>) -> bool, RegionContext<'g>> 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

type Neighbours<'a> = MapSpecialCase<<FilteredGraph<&'g MultiPortGraph, fn(_: NodeIndex, _: &RegionContext<'g>) -> bool, fn(_: PortIndex, _: &RegionContext<'g>) -> bool, RegionContext<'g>> as LinkView>::Neighbours<'a>, MapSpecialCaseFnInto<Node>> where Self: 'a

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

type PortLinks<'a> = MapCtx<WithCtx<<FilteredGraph<&'g MultiPortGraph, fn(_: NodeIndex, _: &RegionContext<'g>) -> bool, fn(_: PortIndex, _: &RegionContext<'g>) -> bool, RegionContext<'g>> as LinkView>::PortLinks<'a>, &'a DescendantsGraph<'g, Root>>, (Node, Port)> where Self: 'a

Iterator over the children of a node

type NodeConnections<'a> = MapCtx<WithCtx<<FilteredGraph<&'g MultiPortGraph, fn(_: NodeIndex, _: &RegionContext<'g>) -> bool, fn(_: PortIndex, _: &RegionContext<'g>) -> bool, RegionContext<'g>> as LinkView>::NodeConnections<'a>, &'a DescendantsGraph<'g, Root>>, [Port; 2]> where Self: 'a

Iterator over the links between two nodes.

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

Returns whether the node exists.

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 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 children(&self, node: Node) -> Self::Children<'_>

Return iterator over the direct children of node.

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) -> &OpType

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_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 inner_function_type(&self) -> Option<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 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<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 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 DescendantsGraph<'g, Root>

type RootHandle = Root

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