Struct hugr_core::hugr::views::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: 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 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)

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<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 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. TODO: Add a version which ignores input extensions

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.