Struct OpaqueValue

pub struct OpaqueValue { /* private fields */ }

An opaque newtype around a Box<dyn CustomConst>.

This type has special serialization behaviour in order to support serialization and deserialization of unknown impls of CustomConst.

During serialization we first serialize the internal dyn CustomConst into a serde_json::Value. We then create a CustomSerialized wrapping that value. That CustomSerialized is then serialized in place of the OpaqueValue.

During deserialization, first we deserialize a CustomSerialized. We attempt to deserialize the internal serde_json::Value using the Box<dyn CustomConst> impl. This will fail if the appropriate impl CustomConst is not linked into the running program, in which case we coerce the CustomSerialized into a Box<dyn CustomConst>. The OpaqueValue is then produced from the Box<dyn [CustomConst]>.

In the case where the internal serialized value of a CustomSerialized is another CustomSerialized we do not attempt to recurse. This behaviour may change in future.

use serde::{Serialize,Deserialize};
use hugr::{
  types::Type,ops::constant::{OpaqueValue, ValueName, CustomConst, CustomSerialized},
  extension::{ExtensionSet, prelude::{usize_t, ConstUsize}},
  std_extensions::arithmetic::int_types};
use serde_json::json;

let expected_json = json!({
    "extensions": ["prelude"],
    "typ": usize_t(),
    "value": {'c': "ConstUsize", 'v': 1}
});
let ev = OpaqueValue::new(ConstUsize::new(1));
assert_eq!(&serde_json::to_value(&ev).unwrap(), &expected_json);
assert_eq!(ev, serde_json::from_value(expected_json).unwrap());

let ev = OpaqueValue::new(CustomSerialized::new(usize_t().clone(), serde_json::Value::Null, ExtensionSet::default()));
let expected_json = json!({
    "extensions": [],
    "typ": usize_t(),
    "value": null
});

assert_eq!(&serde_json::to_value(ev.clone()).unwrap(), &expected_json);
assert_eq!(ev, serde_json::from_value(expected_json).unwrap());

Implementations

impl OpaqueValue

pub fn new(cc: impl CustomConst) -> Self

Create a new OpaqueValue from any CustomConst.

pub fn value(&self) -> &dyn CustomConst

Returns a reference to the internal CustomConst.

pub fn get_type(&self) -> Type

Returns the type of the internal CustomConst.

pub fn name(&self) -> ValueName

An identifier of the internal CustomConst.

pub fn extension_reqs(&self) -> ExtensionSet

The extension(s) defining the internal CustomConst.

Trait Implementations

impl Clone for OpaqueValue

fn clone(&self) -> OpaqueValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OpaqueValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OpaqueValue

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Box<dyn CustomConst>> for OpaqueValue

fn from(value: Box<dyn CustomConst>) -> Self

Converts to this type from the input type.

impl<CC: CustomConst> From<CC> for OpaqueValue

fn from(x: CC) -> Self

Converts to this type from the input type.

impl PartialEq for OpaqueValue

fn eq(&self, other: &Self) -> 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 OpaqueValue

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

where __S: Serializer,

Serialize this value into the given Serde serializer.