Struct Package

pub struct Package {
    pub modules: Vec<Hugr>,
    pub extensions: Vec<Extension>,
}

Package of module HUGRs and extensions. The HUGRs are validated against the extensions.

Fields

modules: Vec<Hugr>

Module HUGRs included in the package.

extensions: Vec<Extension>

Extensions to validate against.

Implementations

impl Package

pub fn new( modules: impl IntoIterator<Item = Hugr>, extensions: impl IntoIterator<Item = Extension>, ) -> Result<Package, PackageError>

Create a new package from a list of hugrs and extensions.

All the HUGRs must have a Module operation at the root.

Errors

Returns an error if any of the HUGRs does not have a Module root.

pub fn from_hugrs( modules: impl IntoIterator<Item = Hugr>, extensions: impl IntoIterator<Item = Extension>, ) -> Result<Package, PackageError>

Create a new package from a list of hugrs and extensions.

HUGRs that do not have a Module root will be wrapped in a new Module root, depending on the root optype.

• Currently all non-module roots will raise PackageError::CannotWrapHugr.

Errors

Returns an error if any of the HUGRs cannot be wrapped in a module.

pub fn from_hugr(hugr: Hugr) -> Result<Package, PackageError>

Create a new package containing a single HUGR, and no extension definitions.

If the Hugr is not a module, a new OpType::Module root will be added. This behaviours depends on the root optype.

• Currently all non-module roots will raise PackageError::CannotWrapHugr.

Errors

Returns an error if the hugr cannot be wrapped in a module.

pub fn update_validate( &mut self, reg: &mut ExtensionRegistry, ) -> Result<(), PackageValidationError>

Validate the package against an extension registry.

reg is updated with any new extensions.

pub fn validate( self, reg: &mut ExtensionRegistry, ) -> Result<Vec<Hugr>, PackageValidationError>

👎Deprecated since 0.13.2: Replaced by Package::update_validate

Validate the package against an extension registry.

reg is updated with any new extensions.

Returns the validated modules.

deprecated: use Package::update_validate instead.

pub fn from_json_reader( reader: impl Read, ) -> Result<Package, PackageEncodingError>

Read a Package in json format from an io reader.

If the json encodes a single Hugr instead, it will be inserted in a new Package.

pub fn from_json(json: impl AsRef<str>) -> Result<Package, PackageEncodingError>

Read a Package from a json string.

If the json encodes a single Hugr instead, it will be inserted in a new Package.

pub fn from_json_file( path: impl AsRef<Path>, ) -> Result<Package, PackageEncodingError>

Read a Package from a json file.

If the json encodes a single Hugr instead, it will be inserted in a new Package.

pub fn to_json_writer( &self, writer: impl Write, ) -> Result<(), PackageEncodingError>

Write the Package in json format into an io writer.

pub fn to_json(&self) -> Result<String, PackageEncodingError>

Write the Package into a json string.

If the json encodes a single Hugr instead, it will be inserted in a new Package.

pub fn to_json_file( &self, path: impl AsRef<Path>, ) -> Result<(), PackageEncodingError>

Write the Package into a json file.

Trait Implementations

impl AsRef<[Hugr]> for Package

fn as_ref(&self) -> &[Hugr]

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

impl Clone for Package

fn clone(&self) -> Package

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Package

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

Formats the value using the given formatter.

impl Default for Package

fn default() -> Package

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Package

fn deserialize<__D>( __deserializer: __D, ) -> Result<Package, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Package

fn eq(&self, other: &Package) -> 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 Serialize for Package

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.