Struct FatNode

pub struct FatNode<'hugr, OT = OpType, H = Hugr, N = Node>
where
    H: ?Sized,
{ /* private fields */ }

A Fat Node is a Node along with a reference to the HugrView whence it originates. It carries a type OT, the OpType of that node. OT may be general, i.e. exactly OpType, or specifec, e.g. FuncDefn.

We provide a [Deref<Target=OT>] impl, so it can be used in place of OT.

We provide PartialEq, Eq, PartialOrd, Ord, Hash, so that this type can be used in containers. Note that these implementations use only the stored node, so will silently malfunction if used with FatNodes from different base Hugrs. Note that Node has this same behaviour.

Implementations

impl<'hugr, OT, H: HugrView + ?Sized> FatNode<'hugr, OT, H, H::Node>

where for<'a> &'a OpType: TryInto<&'a OT>,

pub fn new(hugr: &'hugr H, node: H::Node, ot: &OT) -> Self

Create a FatNode from a HugrView and a Node.

Panics if the node is not valid in the Hugr or if it’s get_optype is not an OT.

Note that while we do check the type of the node’s get_optype, we do not verify that it is actually equal to ot.

pub fn try_new(hugr: &'hugr H, node: H::Node) -> Option<Self>

Tries to create a FatNode from a HugrView and a node (typically a Node).

If the node is invalid, or if its get_optype is not OT, returns None.

pub fn generalise(self) -> FatNode<'hugr, OpType, H, H::Node>

Create a general FatNode from a specific one.

impl<'hugr, OT, H, N: HugrNode> FatNode<'hugr, OT, H, N>

pub fn node(&self) -> N

Gets the Node of the FatNode.

pub fn hugr(&self) -> &'hugr H

Gets the HugrView of the FatNode.

impl<'hugr, H: HugrView + ?Sized> FatNode<'hugr, OpType, H, H::Node>

pub fn new_optype(hugr: &'hugr H, node: H::Node) -> Self

Creates a new general FatNode from a HugrView and a Node.

Panics if the node is not valid in the Hugr.

pub fn try_into_ot<OT>(&self) -> Option<FatNode<'hugr, OT, H, H::Node>>

where for<'a> &'a OpType: TryInto<&'a OT>,

Tries to downcast a general FatNode into a specific OT.

pub fn into_ot<OT>(self, ot: &OT) -> FatNode<'hugr, OT, H, H::Node>

where for<'a> &'a OpType: TryInto<&'a OT>,

Creates a specific FatNode from a general FatNode.

Panics if the node is not valid in the Hugr or if its get_optype is not an OT.

Note that while we do check the type of the node’s get_optype, we do not verify that it is actually equal to ot.

impl<'hugr, OT, H: HugrView + ?Sized> FatNode<'hugr, OT, H, H::Node>

pub fn single_linked_output( &self, port: IncomingPort, ) -> Option<(FatNode<'hugr, OpType, H, H::Node>, OutgoingPort)>

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

pub fn out_value_types( &self, ) -> impl Iterator<Item = (OutgoingPort, Type)> + 'hugr

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

pub fn in_value_types( &self, ) -> impl Iterator<Item = (IncomingPort, Type)> + 'hugr

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

pub fn children( &self, ) -> impl Iterator<Item = FatNode<'hugr, OpType, H, H::Node>> + 'hugr

Return iterator over the direct children of node.

pub fn get_io( &self, ) -> Option<(FatNode<'hugr, Input, H, H::Node>, FatNode<'hugr, Output, H, H::Node>)>

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

pub fn node_outputs(&self) -> impl Iterator<Item = OutgoingPort> + 'hugr

Iterator over output ports of node.

pub fn output_neighbours( &self, ) -> impl Iterator<Item = FatNode<'hugr, OpType, H, H::Node>> + 'hugr

Iterates over the output neighbours of the node.

pub fn try_new_hierarchy_view<HV: HierarchyView<'hugr, Node = H::Node>>( &self, ) -> Result<HV, HugrError>

where H: Sized,

Delegates to HV::try_new with the internal HugrView and Node.

impl<'hugr, H: HugrView> FatNode<'hugr, CFG, H, H::Node>

pub fn get_entry_exit( &self, ) -> (FatNode<'hugr, DataflowBlock, H, H::Node>, FatNode<'hugr, ExitBlock, H, H::Node>)

Returns the entry and exit nodes of a CFG.

These are guaranteed to exist the Hugr is valid. Panics if they do not exist.

Trait Implementations

impl<OT, H: HugrView + ?Sized> AsRef<OT> for FatNode<'_, OT, H, H::Node>

where for<'a> &'a OpType: TryInto<&'a OT>,

fn as_ref(&self) -> &OT

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

impl<OT, H> Clone for FatNode<'_, OT, H>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'hugr, OT: Debug, H, N: Debug> Debug for FatNode<'hugr, OT, H, N>

where H: ?Sized + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<OT, H: HugrView + ?Sized> Deref for FatNode<'_, OT, H, H::Node>

where for<'a> &'a OpType: TryInto<&'a OT>,

type Target = OT

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<OT: NamedOp, H: HugrView + ?Sized> Display for FatNode<'_, OT, H, H::Node>

where for<'a> &'a OpType: TryInto<&'a OT>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<OT, H, N: Hash> Hash for FatNode<'_, OT, H, N>

fn hash<HA: Hasher>(&self, state: &mut HA)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<OT, H> NodeIndex for &FatNode<'_, OT, H>

fn index(self) -> usize

Returns the index of the node.

impl<OT, H, N: NodeIndex> NodeIndex for FatNode<'_, OT, H, N>

fn index(self) -> usize

Returns the index of the node.

impl<OT, H, N: Ord> Ord for FatNode<'_, OT, H, N>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<OT, H> PartialEq<FatNode<'_, OT, H>> for Node

fn eq(&self, other: &FatNode<'_, OT, H, Node>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N: PartialEq, OT1, OT2, H1, H2> PartialEq<FatNode<'_, OT1, H1, N>> for FatNode<'_, OT2, H2, N>

fn eq(&self, other: &FatNode<'_, OT1, H1, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT, H> PartialEq<Node> for FatNode<'_, OT, H, Node>

fn eq(&self, other: &Node) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT, H> PartialOrd<FatNode<'_, OT, H>> for Node

fn partial_cmp(&self, other: &FatNode<'_, OT, H>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<N: PartialOrd, OT1, OT2, H1, H2> PartialOrd<FatNode<'_, OT1, H1, N>> for FatNode<'_, OT2, H2, N>

fn partial_cmp(&self, other: &FatNode<'_, OT1, H1, N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<OT, H> PartialOrd<Node> for FatNode<'_, OT, H>

fn partial_cmp(&self, other: &Node) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<OT, H> Copy for FatNode<'_, OT, H>

impl<N: Eq, OT, H> Eq for FatNode<'_, OT, H, N>