Struct Module

pub struct Module<'a> {
    pub root: RegionId,
    pub nodes: Vec<Node<'a>>,
    pub regions: Vec<Region<'a>>,
    pub terms: Vec<Term<'a>>,
}

A module consisting of a hugr graph together with terms.

Fields

root: RegionId

The id of the root region.

nodes: Vec<Node<'a>>

Table of Nodes.

regions: Vec<Region<'a>>

Table of Regions.

terms: Vec<Term<'a>>

Table of Terms.

Implementations

impl<'a> Module<'a>

pub fn get_node(&self, node_id: NodeId) -> Option<&Node<'a>>

Return the node data for a given node id.

pub fn get_node_mut(&mut self, node_id: NodeId) -> Option<&mut Node<'a>>

Return a mutable reference to the node data for a given node id.

pub fn insert_node(&mut self, node: Node<'a>) -> NodeId

Insert a new node into the module and return its id.

pub fn get_term(&self, term_id: TermId) -> Option<&Term<'a>>

Return the term data for a given term id.

pub fn get_term_mut(&mut self, term_id: TermId) -> Option<&mut Term<'a>>

Return a mutable reference to the term data for a given term id.

pub fn insert_term(&mut self, term: Term<'a>) -> TermId

Insert a new term into the module and return its id.

pub fn get_region(&self, region_id: RegionId) -> Option<&Region<'a>>

Return the region data for a given region id.

pub fn get_region_mut(&mut self, region_id: RegionId) -> Option<&mut Region<'a>>

Return a mutable reference to the region data for a given region id.

pub fn insert_region(&mut self, region: Region<'a>) -> RegionId

Insert a new region into the module and return its id.

Trait Implementations

impl<'a> Clone for Module<'a>

fn clone(&self) -> Module<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Module<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Module<'a>

fn default() -> Module<'a>

Returns the “default value” for a type.

impl<'a> Hash for Module<'a>

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

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<'a> PartialEq for Module<'a>

fn eq(&self, other: &Module<'a>) -> 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<'a> Eq for Module<'a>

impl<'a> StructuralPartialEq for Module<'a>