Source code
Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
use super::{FromValueError, Node, Result};
use std::{collections::HashMap, fmt};
/// Represents the value of a node
///
/// This is a loosely typed data structure similar to `serde_json::Value`.
/// Nodes can be converted to/from `Value` which is what allows nodes to automatically be converted
/// from one IR to another.
pub enum Value {
UInt8(u8),
Int8(i8),
UInt16(u16),
Int16(i16),
UInt32(u32),
Int32(i32),
UInt64(u64),
Int64(i64),
Float32(f32),
Float64(f64),
String(String),
Bool(bool),
Option(Option<Box<Value>>),
Vec(Vec<Value>),
Map(Vec<(Value, Value)>),
Set(Vec<Value>),
Struct {
type_name: &'static str,
fields: HashMap<&'static str, Value>,
},
Variant {
type_name: &'static str,
variant_name: &'static str,
fields: HashMap<&'static str, Value>,
},
}
impl Value {
pub fn try_into_node<T: Node>(self) -> Result<T, FromValueError> {
T::try_from_value(self)
}
}
impl fmt::Debug for Value {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::UInt8(val) => write!(f, "{val}u8"),
Self::Int8(val) => write!(f, "{val}i8"),
Self::UInt16(val) => write!(f, "{val}u16"),
Self::Int16(val) => write!(f, "{val}i16"),
Self::UInt32(val) => write!(f, "{val}u32"),
Self::Int32(val) => write!(f, "{val}i32"),
Self::UInt64(val) => write!(f, "{val}u64"),
Self::Int64(val) => write!(f, "{val}i64"),
Self::Float32(val) => write!(f, "{val}f32"),
Self::Float64(val) => write!(f, "{val}f64"),
Self::String(val) => write!(f, "{val:?}"),
Self::Bool(val) => write!(f, "{val:?}"),
Self::Option(val) => match val {
Some(v) => f.debug_tuple("Some").field(v).finish(),
None => f.debug_tuple("None").finish(),
},
Self::Vec(values) => f.debug_list().entries(values).finish(),
Self::Map(values) => f
.debug_map()
.entries(values.iter().map(|(k, v)| (k, v)))
.finish(),
Self::Set(values) => f.debug_set().entries(values.iter()).finish(),
Self::Struct { type_name, fields } => {
let mut f = f.debug_struct(type_name);
for (name, val) in fields {
f.field(name, val);
}
f.finish()
}
Self::Variant {
type_name,
variant_name,
fields,
} => {
let mut f = f.debug_struct(&format!("{type_name}::{variant_name}"));
for (name, val) in fields {
f.field(name, val);
}
f.finish()
}
}
}
}