use self::Value::*;
use crate::{
AnyQuery, AsValue, Error, Expression, GenericSqlWriter, Result, TableRef, interval::Interval,
};
use anyhow::anyhow;
use quote::{ToTokens, quote};
use rust_decimal::{Decimal, prelude::ToPrimitive};
use serde_json::{Number, Value as JsonValue};
use std::{
borrow::Cow,
collections::{HashMap, hash_map::DefaultHasher},
fmt::{self, Display},
hash::{Hash, Hasher},
iter,
mem::{self, discriminant},
net::IpAddr,
};
use time::{Date, OffsetDateTime, PrimitiveDateTime, Time};
use uuid::Uuid;
#[derive(Default, Debug, Clone)]
pub enum Value<'a> {
#[default]
Null,
Boolean(Option<bool>),
Int8(Option<i8>),
Int16(Option<i16>),
Int32(Option<i32>),
Int64(Option<i64>),
Int128(Option<Box<i128>>),
UInt8(Option<u8>),
UInt16(Option<u16>),
UInt32(Option<u32>),
UInt64(Option<u64>),
UInt128(Option<Box<u128>>),
Float32(Option<f32>),
Float64(Option<f64>),
Decimal(Option<Decimal>, u8, u8),
Char(Option<char>),
Varchar(Option<Cow<'a, str>>),
Blob(Option<Cow<'a, [u8]>>),
Date(Option<Date>),
Time(Option<Time>),
Timestamp(Option<PrimitiveDateTime>),
TimestampWithTimezone(Option<OffsetDateTime>),
Interval(Option<Interval>),
Uuid(Option<Uuid>),
IpAddr(Option<IpAddr>),
Array(Option<Box<[Value<'a>]>>, Box<CollectionType<'a>>),
List(Option<Box<[Value<'a>]>>, Box<CollectionType<'a>>),
Map(Option<Box<HashMap<Value<'a>, Value<'a>>>>, Box<MapType<'a>>),
Json(Option<JsonValue>),
Struct(Option<Box<[(String, Value<'a>)]>>, Box<StructType<'a>>),
Unknown(Option<Cow<'a, str>>),
}
#[derive(Debug, Clone)]
pub struct CollectionType<'a> {
pub element: Value<'a>,
pub len: u32,
}
#[derive(Debug, Clone)]
pub struct MapType<'a> {
pub key: Value<'a>,
pub value: Value<'a>,
}
#[derive(Debug, Clone)]
pub struct StructType<'a> {
pub fields: Vec<(String, Value<'a>)>,
pub name: TableRef,
}
pub type ValueOwned = Value<'static>;
impl<'a> Value<'a> {
pub fn same_type(&self, other: &Value<'_>) -> bool {
match (self, other) {
(Value::Decimal(_, l_width, l_scale, ..), Value::Decimal(_, r_width, r_scale, ..)) => {
(*l_width == 0 || *r_width == 0 || l_width == r_width)
&& (*l_scale == 0 || *r_scale == 0 || l_scale == r_scale)
}
(Value::Array(_, l, ..), Value::Array(_, r, ..))
| (Value::List(_, l, ..), Value::List(_, r, ..)) => {
l.len == r.len && l.element.same_type(&r.element)
}
(Value::Map(_, l, ..), Value::Map(_, r, ..)) => {
l.key.same_type(&r.key) && l.value.same_type(&r.value)
}
(Value::Struct(_, l, ..), Value::Struct(_, r, ..)) => {
l.name == r.name
&& l.fields.len() == r.fields.len()
&& iter::zip(&l.fields, &r.fields)
.all(|((ln, lt), (rn, rt))| ln == rn && lt.same_type(rt))
}
_ => discriminant(self) == discriminant(other),
}
}
#[inline(always)]
pub const fn is_null(&self) -> bool {
match self {
Value::Null
| Value::Boolean(None, ..)
| Value::Int8(None, ..)
| Value::Int16(None, ..)
| Value::Int32(None, ..)
| Value::Int64(None, ..)
| Value::Int128(None, ..)
| Value::UInt8(None, ..)
| Value::UInt16(None, ..)
| Value::UInt32(None, ..)
| Value::UInt64(None, ..)
| Value::UInt128(None, ..)
| Value::Float32(None, ..)
| Value::Float64(None, ..)
| Value::Decimal(None, ..)
| Value::Char(None, ..)
| Value::Varchar(None, ..)
| Value::Blob(None, ..)
| Value::Date(None, ..)
| Value::Time(None, ..)
| Value::Timestamp(None, ..)
| Value::TimestampWithTimezone(None, ..)
| Value::Interval(None, ..)
| Value::Uuid(None, ..)
| Value::IpAddr(None, ..)
| Value::Array(None, ..)
| Value::List(None, ..)
| Value::Map(None, ..)
| Value::Json(None | Some(JsonValue::Null), ..)
| Value::Struct(None, ..)
| Value::Unknown(None, ..) => true,
_ => false,
}
}
pub fn as_null(&self) -> Value<'a> {
match self {
Value::Null => Value::Null,
Value::Boolean(..) => Value::Boolean(None),
Value::Int8(..) => Value::Int8(None),
Value::Int16(..) => Value::Int16(None),
Value::Int32(..) => Value::Int32(None),
Value::Int64(..) => Value::Int64(None),
Value::Int128(..) => Value::Int128(None),
Value::UInt8(..) => Value::UInt8(None),
Value::UInt16(..) => Value::UInt16(None),
Value::UInt32(..) => Value::UInt32(None),
Value::UInt64(..) => Value::UInt64(None),
Value::UInt128(..) => Value::UInt128(None),
Value::Float32(..) => Value::Float32(None),
Value::Float64(..) => Value::Float64(None),
Value::Decimal(_, w, s, ..) => Value::Decimal(None, *w, *s),
Value::Char(..) => Value::Char(None),
Value::Varchar(..) => Value::Varchar(None),
Value::Blob(..) => Value::Blob(None),
Value::Date(..) => Value::Date(None),
Value::Time(..) => Value::Time(None),
Value::Timestamp(..) => Value::Timestamp(None),
Value::TimestampWithTimezone(..) => Value::TimestampWithTimezone(None),
Value::Interval(..) => Value::Interval(None),
Value::Uuid(..) => Value::Uuid(None),
Value::IpAddr(..) => Value::IpAddr(None),
Value::Array(_, t, ..) => Value::Array(None, t.clone()),
Value::List(_, t, ..) => Value::List(None, t.clone()),
Value::Map(_, t, ..) => Value::Map(None, t.clone()),
Value::Json(..) => Value::Json(None),
Value::Struct(_, t, ..) => Value::Struct(None, t.clone()),
Value::Unknown(..) => Value::Unknown(None),
}
}
pub fn try_as(self, target_type: &Value<'_>) -> Result<Value<'a>> {
if self.same_type(target_type) {
return Ok(self);
}
match target_type {
Value::Boolean(..) => bool::decode_value(self).map(AsValue::as_value),
Value::Int8(..) => i8::decode_value(self).map(AsValue::as_value),
Value::Int16(..) => i16::decode_value(self).map(AsValue::as_value),
Value::Int32(..) => i32::decode_value(self).map(AsValue::as_value),
Value::Int64(..) => i64::decode_value(self).map(AsValue::as_value),
Value::Int128(..) => i128::decode_value(self).map(AsValue::as_value),
Value::UInt8(..) => u8::decode_value(self).map(AsValue::as_value),
Value::UInt16(..) => u16::decode_value(self).map(AsValue::as_value),
Value::UInt32(..) => u32::decode_value(self).map(AsValue::as_value),
Value::UInt64(..) => u64::decode_value(self).map(AsValue::as_value),
Value::UInt128(..) => u128::decode_value(self).map(AsValue::as_value),
Value::Float32(..) => f32::decode_value(self).map(AsValue::as_value),
Value::Float64(..) => f64::decode_value(self).map(AsValue::as_value),
Value::Decimal(..) => Decimal::decode_value(self).map(AsValue::as_value),
Value::Char(..) => char::decode_value(self).map(AsValue::as_value),
Value::Varchar(..) => String::decode_value(self).map(AsValue::as_value),
Value::Blob(..) => Box::<[u8]>::decode_value(self).map(AsValue::as_value),
Value::Date(..) => Date::decode_value(self).map(AsValue::as_value),
Value::Time(..) => Time::decode_value(self).map(AsValue::as_value),
Value::Timestamp(..) => PrimitiveDateTime::decode_value(self).map(AsValue::as_value),
Value::TimestampWithTimezone(..) => {
OffsetDateTime::decode_value(self).map(AsValue::as_value)
}
Value::Interval(..) => Interval::decode_value(self).map(AsValue::as_value),
Value::Uuid(..) => Uuid::decode_value(self).map(AsValue::as_value),
Value::IpAddr(..) => IpAddr::decode_value(self).map(AsValue::as_value),
_ => {
return Err(anyhow!(
"Cannot convert value {:?} to {:?}",
self,
target_type
));
}
}
}
pub const fn is_scalar(&self) -> bool {
match self {
Value::Boolean(..)
| Value::Int8(..)
| Value::Int16(..)
| Value::Int32(..)
| Value::Int64(..)
| Value::Int128(..)
| Value::UInt8(..)
| Value::UInt16(..)
| Value::UInt32(..)
| Value::UInt64(..)
| Value::UInt128(..)
| Value::Float32(..)
| Value::Float64(..)
| Value::Decimal(..)
| Value::Char(..)
| Value::Varchar(..)
| Value::Blob(..)
| Value::Date(..)
| Value::Time(..)
| Value::Timestamp(..)
| Value::TimestampWithTimezone(..)
| Value::Interval(..)
| Value::Uuid(..)
| Value::IpAddr(..)
| Value::Unknown(..) => true,
_ => false,
}
}
#[cold]
#[inline(never)]
fn into_owned_nested(self) -> ValueOwned {
match self {
Value::Array(v, t) => Value::Array(
v.map(|v| v.into_vec().into_iter().map(Value::into_owned).collect()),
Box::new(CollectionType {
element: t.element.into_owned(),
len: t.len,
}),
),
Value::List(v, t) => Value::List(
v.map(|v| v.into_vec().into_iter().map(Value::into_owned).collect()),
Box::new(CollectionType {
element: t.element.into_owned(),
len: t.len,
}),
),
Value::Map(v, t) => Value::Map(
v.map(|v| {
Box::new(
v.into_iter()
.map(|(k, v)| (k.into_owned(), v.into_owned()))
.collect(),
)
}),
Box::new(MapType {
key: t.key.into_owned(),
value: t.value.into_owned(),
}),
),
Value::Struct(v, t) => Value::Struct(
v.map(|v| {
v.into_vec()
.into_iter()
.map(|(k, v)| (k, v.into_owned()))
.collect()
}),
Box::new(StructType {
fields: t
.fields
.into_iter()
.map(|(k, v)| (k, v.into_owned()))
.collect(),
name: t.name,
}),
),
other => {
log::error!("Unexpected non composite value value: {other:?}");
Value::Null
}
}
}
#[inline]
pub fn into_owned(self) -> ValueOwned {
'simple_value: {
let owned = match self {
Value::Varchar(Some(Cow::Borrowed(v))) => {
Value::Varchar(Some(Cow::Owned(v.to_owned())))
}
Value::Blob(Some(Cow::Borrowed(v))) => Value::Blob(Some(Cow::Owned(v.to_owned()))),
Value::Unknown(Some(Cow::Borrowed(v))) => {
Value::Unknown(Some(Cow::Owned(v.to_owned())))
}
Value::Array(..) | Value::List(..) | Value::Map(..) | Value::Struct(..) => {
break 'simple_value self.into_owned_nested();
}
other => {
break 'simple_value unsafe { mem::transmute::<Value<'a>, ValueOwned>(other) };
}
};
mem::forget(self);
owned
}
}
}
impl<'a> From<JsonValue> for Value<'a> {
fn from(value: JsonValue) -> Self {
match value {
JsonValue::Null => Value::Null,
JsonValue::Bool(v) => Value::Boolean(Some(v)),
JsonValue::Number(v) => {
if let Some(v) = v.as_i64() {
Value::Int64(Some(v))
} else if let Some(v) = v.as_i128() {
Value::Int128(Some(Box::new(v)))
} else if let Some(v) = v.as_u128() {
Value::UInt128(Some(Box::new(v)))
} else if let Some(v) = v.as_f64() {
Value::Float64(Some(v))
} else {
Value::Json(Some(JsonValue::Number(v)))
}
}
JsonValue::String(v) => Value::Varchar(Some(v.into())),
JsonValue::Array(v) => {
let values: Vec<Value<'a>> = v.into_iter().map(Value::from).collect();
let element = values
.first()
.map(Value::as_null)
.unwrap_or(Value::Unknown(None));
Value::List(
Some(values.into_boxed_slice()),
Box::new(CollectionType { element, len: 0 }),
)
}
JsonValue::Object(v) => {
let mut entries = HashMap::with_capacity(v.len());
let mut value_type = None;
for (k, v) in v {
let v = Value::from(v);
value_type.get_or_insert_with(|| v.as_null());
entries.insert(Value::Varchar(Some(k.into())), v);
}
Value::Map(
Some(Box::new(entries)),
Box::new(MapType {
key: Value::Varchar(None),
value: value_type.unwrap_or(Value::Unknown(None)),
}),
)
}
}
}
}
impl<'a> TryFrom<Value<'a>> for JsonValue {
type Error = Error;
fn try_from(value: Value<'a>) -> Result<Self> {
Ok(match value {
Value::Json(Some(v)) => v,
value if value.is_null() => Self::Null,
Value::Boolean(Some(v)) => Self::Bool(v),
Value::Int8(Some(v)) => Self::from(v),
Value::Int16(Some(v)) => Self::from(v),
Value::Int32(Some(v)) => Self::from(v),
Value::Int64(Some(v)) => Self::from(v),
Value::Int128(Some(v)) => Self::Number(
Number::from_i128(*v)
.ok_or_else(|| anyhow!("Value {v}: i128 does not fit into a JSON number"))?,
),
Value::UInt8(Some(v)) => Self::from(v),
Value::UInt16(Some(v)) => Self::from(v),
Value::UInt32(Some(v)) => Self::from(v),
Value::UInt64(Some(v)) => Self::from(v),
Value::UInt128(Some(v)) => Self::Number(
Number::from_u128(*v)
.ok_or_else(|| anyhow!("Value {v}: u128 does not fit into a JSON number"))?,
),
Value::Float32(Some(v)) => Self::Number(
Number::from_f64(v as f64)
.ok_or_else(|| anyhow!("Value {v}: f32 does not fit into a JSON number"))?,
),
Value::Float64(Some(v)) => Self::Number(
Number::from_f64(v)
.ok_or_else(|| anyhow!("Value {v}: f64 does not fit into a JSON number"))?,
),
Value::Decimal(Some(v), ..) => Self::Number(
v.to_f64()
.and_then(Number::from_f64)
.ok_or_else(|| anyhow!("Value {v}: Decimal does not fit into a JSON number"))?,
),
Value::Char(Some(v)) => Self::String(v.to_string()),
Value::Varchar(Some(v)) => Self::String(v.into_owned()),
Value::Blob(Some(v)) => Self::Array(v.iter().map(|v| Self::from(*v)).collect()),
Value::Array(Some(v), ..) | Value::List(Some(v), ..) => Self::Array(
v.into_iter()
.map(|v| Self::try_from(v))
.collect::<Result<_>>()?,
),
Value::Map(Some(v), ..) => Self::Object(
v.into_iter()
.map(|(k, v)| Ok((String::decode_value(k)?, Self::try_from(v)?)))
.collect::<Result<_>>()?,
),
Value::Struct(Some(v), ..) => Self::Object(
v.into_iter()
.map(|(k, v)| Ok((k, Self::try_from(v)?)))
.collect::<Result<_>>()?,
),
Value::Unknown(Some(v)) => Self::String(v.into_owned()),
v @ (Value::Date(Some(..))
| Value::Time(Some(..))
| Value::Timestamp(Some(..))
| Value::TimestampWithTimezone(Some(..))
| Value::Uuid(Some(..))
| Value::IpAddr(Some(..))) => Self::String(v.to_string()),
v => return Err(anyhow!("Cannot convert {v:?} to serde_json::Value")),
})
}
}
impl PartialEq for Value<'_> {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(Self::Null, Self::Null) => true,
(Self::Boolean(l), Self::Boolean(r)) => l == r,
(Self::Int8(l), Self::Int8(r)) => l == r,
(Self::Int16(l), Self::Int16(r)) => l == r,
(Self::Int32(l), Self::Int32(r)) => l == r,
(Self::Int64(l), Self::Int64(r)) => l == r,
(Self::Int128(l), Self::Int128(r)) => l == r,
(Self::UInt8(l), Self::UInt8(r)) => l == r,
(Self::UInt16(l), Self::UInt16(r)) => l == r,
(Self::UInt32(l), Self::UInt32(r)) => l == r,
(Self::UInt64(l), Self::UInt64(r)) => l == r,
(Self::UInt128(l), Self::UInt128(r)) => l == r,
(Self::Float32(l), Self::Float32(r)) => {
l == r
|| l.and_then(|l| r.and_then(|r| Some(l.is_nan() && r.is_nan())))
.unwrap_or_default()
}
(Self::Float64(l), Self::Float64(r)) => {
l == r
|| l.and_then(|l| r.and_then(|r| Some(l.is_nan() && r.is_nan())))
.unwrap_or_default()
}
(Self::Decimal(l, l_width, l_scale), Self::Decimal(r, r_width, r_scale)) => {
l == r && l_width == r_width && l_scale == r_scale
}
(Self::Char(l), Self::Char(r)) => l == r,
(Self::Varchar(l), Self::Varchar(r)) => l == r,
(Self::Blob(l), Self::Blob(r)) => l == r,
(Self::Date(l), Self::Date(r)) => l == r,
(Self::Time(l), Self::Time(r)) => l == r,
(Self::Timestamp(l), Self::Timestamp(r)) => l == r,
(Self::TimestampWithTimezone(l), Self::TimestampWithTimezone(r)) => l == r,
(Self::Interval(l), Self::Interval(r)) => l == r,
(Self::Uuid(l), Self::Uuid(r)) => l == r,
(Self::IpAddr(l), Self::IpAddr(r)) => l == r,
(Self::Array(l, lt), Self::Array(r, rt)) | (Self::List(l, lt), Self::List(r, rt)) => {
lt.len == rt.len && lt.element == rt.element && l == r
}
(Self::Map(l, lt), Self::Map(r, rt)) => {
lt.key == rt.key && lt.value == rt.value && l == r
}
(Self::Json(l), Self::Json(r)) => l == r,
(Self::Struct(l, lt), Self::Struct(r, rt)) => {
lt.name == rt.name && l == r && lt.fields == rt.fields
}
(Self::Unknown(l), Self::Unknown(r)) => l == r,
_ => false,
}
}
}
impl Eq for Value<'_> {}
fn hash_f32_value<H: std::hash::Hasher>(value: f32, state: &mut H) {
let bits = if value == 0.0 {
0.0f32.to_bits()
} else if value.is_nan() {
f32::NAN.to_bits()
} else {
value.to_bits()
};
bits.hash(state);
}
fn hash_f64_value<H: std::hash::Hasher>(value: f64, state: &mut H) {
let bits = if value == 0.0 {
0.0f64.to_bits()
} else if value.is_nan() {
f64::NAN.to_bits()
} else {
value.to_bits()
};
bits.hash(state);
}
fn hash_map_value<'a, H: std::hash::Hasher>(
value: &Option<Box<HashMap<Value<'a>, Value<'a>>>>,
key_ty: &Value<'a>,
value_ty: &Value<'a>,
state: &mut H,
) {
value.is_some().hash(state);
if let Some(map) = value {
let mut entry_hashes = map
.iter()
.map(|(key, value)| {
let mut hasher = DefaultHasher::new();
key.hash(&mut hasher);
value.hash(&mut hasher);
hasher.finish()
})
.collect::<Vec<_>>();
entry_hashes.sort_unstable();
entry_hashes.hash(state);
}
key_ty.hash(state);
value_ty.hash(state);
}
impl Hash for Value<'_> {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
discriminant(self).hash(state);
match self {
Null => {}
Boolean(v) => v.hash(state),
Int8(v) => v.hash(state),
Int16(v) => v.hash(state),
Int32(v) => v.hash(state),
Int64(v) => v.hash(state),
Int128(v) => v.hash(state),
UInt8(v) => v.hash(state),
UInt16(v) => v.hash(state),
UInt32(v) => v.hash(state),
UInt64(v) => v.hash(state),
UInt128(v) => v.hash(state),
Float32(Some(v)) => hash_f32_value(*v, state),
Float32(None) => None::<u32>.hash(state),
Float64(Some(v)) => hash_f64_value(*v, state),
Float64(None) => None::<u64>.hash(state),
Decimal(v, width, scale) => {
v.hash(state);
width.hash(state);
scale.hash(state);
}
Char(v) => v.hash(state),
Varchar(v) => v.hash(state),
Blob(v) => v.hash(state),
Date(v) => v.hash(state),
Time(v) => v.hash(state),
Timestamp(v) => v.hash(state),
TimestampWithTimezone(v) => v.hash(state),
Interval(v) => v.hash(state),
Uuid(v) => v.hash(state),
IpAddr(v) => v.hash(state),
Array(v, t) | List(v, t) => {
v.hash(state);
t.element.hash(state);
t.len.hash(state);
}
Map(v, t) => hash_map_value(v, &t.key, &t.value, state),
Json(v) => v.hash(state),
Struct(v, t) => {
if let Some(v) = v {
v.hash(state);
}
t.fields.hash(state);
t.name.hash(state);
}
Unknown(v) => v.hash(state),
}
}
}
impl Display for Value<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut out = AnyQuery::default();
self.write_query(&GenericSqlWriter::new(), &mut Default::default(), &mut out);
let _ = f.write_str(out.buffer());
Ok(())
}
}
#[derive(Default)]
pub struct TypeDecoded {
pub value: ValueOwned,
pub nullable: bool,
}
impl ToTokens for Value<'_> {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let ts = match self {
Value::Null => quote!(::tank::Value::Null),
Value::Boolean(..) => quote!(::tank::Value::Boolean(None)),
Value::Int8(..) => quote!(::tank::Value::Int8(None)),
Value::Int16(..) => quote!(::tank::Value::Int16(None)),
Value::Int32(..) => quote!(::tank::Value::Int32(None)),
Value::Int64(..) => quote!(::tank::Value::Int64(None)),
Value::Int128(..) => quote!(::tank::Value::Int128(None)),
Value::UInt8(..) => quote!(::tank::Value::UInt8(None)),
Value::UInt16(..) => quote!(::tank::Value::UInt16(None)),
Value::UInt32(..) => quote!(::tank::Value::UInt32(None)),
Value::UInt64(..) => quote!(::tank::Value::UInt64(None)),
Value::UInt128(..) => quote!(::tank::Value::UInt128(None)),
Value::Float32(..) => quote!(::tank::Value::Float32(None)),
Value::Float64(..) => quote!(::tank::Value::Float64(None)),
Value::Decimal(_, width, scale, ..) => {
quote!(::tank::Value::Decimal(None, #width, #scale))
}
Value::Char(..) => quote!(::tank::Value::Char(None)),
Value::Varchar(..) => quote!(::tank::Value::Varchar(None)),
Value::Blob(..) => quote!(::tank::Value::Blob(None)),
Value::Date(..) => quote!(::tank::Value::Date(None)),
Value::Time(..) => quote!(::tank::Value::Time(None)),
Value::Timestamp(..) => quote!(::tank::Value::Timestamp(None)),
Value::TimestampWithTimezone(..) => quote!(::tank::Value::TimestampWithTimezone(None)),
Value::Interval(..) => quote!(::tank::Value::Interval(None)),
Value::Uuid(..) => quote!(::tank::Value::Uuid(None)),
Value::IpAddr(..) => quote!(::tank::Value::IpAddr(None)),
Value::Array(_, t, ..) => {
let (element, len) = (&t.element, t.len);
quote!(::tank::Value::Array(
None,
Box::new(::tank::CollectionType { element: #element, len: #len }),
))
}
Value::List(_, t, ..) => {
let (element, len) = (&t.element, t.len);
quote!(::tank::Value::List(
None,
Box::new(::tank::CollectionType { element: #element, len: #len }),
))
}
Value::Map(_, t, ..) => {
let (key, value) = (&t.key, &t.value);
quote!(::tank::Value::Map(
None,
Box::new(::tank::MapType { key: #key, value: #value }),
))
}
Value::Json(..) => quote!(::tank::Value::Json(None)),
Value::Struct(_, t, ..) => {
let fields = t.fields.iter().map(|(k, v)| quote!((#k.into(), #v)));
let name = &t.name;
quote!(::tank::Value::Struct(
None,
Box::new(::tank::StructType { fields: vec![#(#fields),*], name: #name }),
))
}
Value::Unknown(..) => quote!(::tank::Value::Unknown(None)),
};
tokens.extend(ts);
}
}