git.delta.rocks / jrsonnet / refs/commits / 2afd5ff0dd7a

1use std::ops::Deref;23use jrsonnet_gcmodule::Cc;4use jrsonnet_interner::{IBytes, IStr};5pub use jrsonnet_macros::Typed;6use jrsonnet_types::{ComplexValType, ValType};78use crate::{9	arr::ArrValue,10	error::Result,11	function::{native::NativeDesc, FuncDesc, FuncVal},12	throw,13	typed::CheckType,14	val::{IndexableVal, StrValue},15	ObjValue, ObjValueBuilder, Val,16};1718pub trait TypedObj: Typed {19	fn serialize(self, out: &mut ObjValueBuilder) -> Result<()>;20	fn parse(obj: &ObjValue) -> Result<Self>;21	fn into_object(self) -> Result<ObjValue> {22		let mut builder = ObjValueBuilder::new();23		self.serialize(&mut builder)?;24		Ok(builder.build())25	}26}2728pub trait Typed: Sized {29	const TYPE: &'static ComplexValType;30	fn into_untyped(typed: Self) -> Result<Val>;31	fn from_untyped(untyped: Val) -> Result<Self>;32}3334const MAX_SAFE_INTEGER: f64 = ((1u64 << (f64::MANTISSA_DIGITS + 1)) - 1) as f64;3536macro_rules! impl_int {37	($($ty:ty)*) => {$(38		impl Typed for $ty {39			const TYPE: &'static ComplexValType =40				&ComplexValType::BoundedNumber(Some(Self::MIN as f64), Some(Self::MAX as f64));41			fn from_untyped(value: Val) -> Result<Self> {42				<Self as Typed>::TYPE.check(&value)?;43				match value {44					Val::Num(n) => {45						#[allow(clippy::float_cmp)]46						if n.trunc() != n {47							throw!(48								"cannot convert number with fractional part to {}",49								stringify!($ty)50							)51						}52						Ok(n as Self)53					}54					_ => unreachable!(),55				}56			}57			fn into_untyped(value: Self) -> Result<Val> {58				Ok(Val::Num(value as f64))59			}60		}61	)*};62}6364impl_int!(i8 u8 i16 u16 i32 u32);6566macro_rules! impl_bounded_int {67	($($name:ident = $ty:ty)*) => {$(68		#[derive(Clone, Copy)]69		pub struct $name<const MIN: $ty, const MAX: $ty>($ty);70		impl<const MIN: $ty, const MAX: $ty> $name<MIN, MAX> {71			pub const fn new(value: $ty) -> Option<$name<MIN, MAX>> {72				if value >= MIN && value <= MAX {73					Some(Self(value))74				} else {75					None76				}77			}78			pub const fn value(self) -> $ty {79				self.080			}81		}82		impl<const MIN: $ty, const MAX: $ty> Deref for $name<MIN, MAX> {83			type Target = $ty;84			fn deref(&self) -> &Self::Target {85				&self.086			}87		}8889		impl<const MIN: $ty, const MAX: $ty> Typed for $name<MIN, MAX> {90			const TYPE: &'static ComplexValType =91				&ComplexValType::BoundedNumber(92					Some(MIN as f64),93					Some(MAX as f64),94				);9596			fn from_untyped(value: Val) -> Result<Self> {97				<Self as Typed>::TYPE.check(&value)?;98				match value {99					Val::Num(n) => {100						#[allow(clippy::float_cmp)]101						if n.trunc() != n {102							throw!(103								"cannot convert number with fractional part to {}",104								stringify!($ty)105							)106						}107						Ok(Self(n as $ty))108					}109					_ => unreachable!(),110				}111			}112113			fn into_untyped(value: Self) -> Result<Val> {114				Ok(Val::Num(value.0 as f64))115			}116		}117	)*};118}119120impl_bounded_int!(121	BoundedI8 = i8122	BoundedI16 = i16123	BoundedI32 = i32124	BoundedI64 = i64125	BoundedUsize = usize126);127128impl Typed for f64 {129	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);130131	fn into_untyped(value: Self) -> Result<Val> {132		Ok(Val::Num(value))133	}134135	fn from_untyped(value: Val) -> Result<Self> {136		<Self as Typed>::TYPE.check(&value)?;137		match value {138			Val::Num(n) => Ok(n),139			_ => unreachable!(),140		}141	}142}143144pub struct PositiveF64(pub f64);145impl Typed for PositiveF64 {146	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);147148	fn into_untyped(value: Self) -> Result<Val> {149		Ok(Val::Num(value.0))150	}151152	fn from_untyped(value: Val) -> Result<Self> {153		<Self as Typed>::TYPE.check(&value)?;154		match value {155			Val::Num(n) => Ok(Self(n)),156			_ => unreachable!(),157		}158	}159}160impl Typed for usize {161	const TYPE: &'static ComplexValType =162		&ComplexValType::BoundedNumber(Some(0.0), Some(MAX_SAFE_INTEGER));163164	fn into_untyped(value: Self) -> Result<Val> {165		if value > MAX_SAFE_INTEGER as Self {166			throw!("number is too large")167		}168		Ok(Val::Num(value as f64))169	}170171	fn from_untyped(value: Val) -> Result<Self> {172		<Self as Typed>::TYPE.check(&value)?;173		match value {174			Val::Num(n) => {175				#[allow(clippy::float_cmp)]176				if n.trunc() != n {177					throw!("cannot convert number with fractional part to usize")178				}179				Ok(n as Self)180			}181			_ => unreachable!(),182		}183	}184}185186impl Typed for IStr {187	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);188189	fn into_untyped(value: Self) -> Result<Val> {190		Ok(Val::Str(StrValue::Flat(value)))191	}192193	fn from_untyped(value: Val) -> Result<Self> {194		<Self as Typed>::TYPE.check(&value)?;195		match value {196			Val::Str(s) => Ok(s.into_flat()),197			_ => unreachable!(),198		}199	}200}201202impl Typed for String {203	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);204205	fn into_untyped(value: Self) -> Result<Val> {206		Ok(Val::Str(StrValue::Flat(value.into())))207	}208209	fn from_untyped(value: Val) -> Result<Self> {210		<Self as Typed>::TYPE.check(&value)?;211		match value {212			Val::Str(s) => Ok(s.to_string()),213			_ => unreachable!(),214		}215	}216}217218impl Typed for char {219	const TYPE: &'static ComplexValType = &ComplexValType::Char;220221	fn into_untyped(value: Self) -> Result<Val> {222		Ok(Val::Str(StrValue::Flat(value.to_string().into())))223	}224225	fn from_untyped(value: Val) -> Result<Self> {226		<Self as Typed>::TYPE.check(&value)?;227		match value {228			Val::Str(s) => Ok(s.into_flat().chars().next().unwrap()),229			_ => unreachable!(),230		}231	}232}233234impl<T> Typed for Vec<T>235where236	T: Typed,237{238	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);239240	fn into_untyped(value: Self) -> Result<Val> {241		let mut o = Vec::with_capacity(value.len());242		for i in value {243			o.push(T::into_untyped(i)?);244		}245		Ok(Val::Arr(o.into()))246	}247248	fn from_untyped(value: Val) -> Result<Self> {249		<Self as Typed>::TYPE.check(&value)?;250		match value {251			Val::Arr(a) => {252				let mut o = Self::with_capacity(a.len());253				for i in a.iter() {254					o.push(T::from_untyped(i?)?);255				}256				Ok(o)257			}258			_ => unreachable!(),259		}260	}261}262263/// To be used in Vec<Any>264/// Regular Val can't be used here, because it has wrong `TryFrom::Error` type265#[derive(Clone)]266pub struct Any(pub Val);267268impl Typed for Any {269	const TYPE: &'static ComplexValType = &ComplexValType::Any;270271	fn into_untyped(value: Self) -> Result<Val> {272		Ok(value.0)273	}274275	fn from_untyped(value: Val) -> Result<Self> {276		Ok(Self(value))277	}278}279280/// Specialization, provides faster `TryFrom<VecVal>` for Val281pub struct VecVal(pub Cc<Vec<Val>>);282283impl Typed for VecVal {284	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);285286	fn into_untyped(value: Self) -> Result<Val> {287		Ok(Val::Arr(ArrValue::eager(value.0)))288	}289290	fn from_untyped(value: Val) -> Result<Self> {291		<Self as Typed>::TYPE.check(&value)?;292		match value {293			Val::Arr(a) => Ok(Self(a.evaluatedcc()?)),294			_ => unreachable!(),295		}296	}297}298299/// Specialization300impl Typed for IBytes {301	const TYPE: &'static ComplexValType =302		&ComplexValType::ArrayRef(&ComplexValType::BoundedNumber(Some(0.0), Some(255.0)));303304	fn into_untyped(value: Self) -> Result<Val> {305		Ok(Val::Arr(ArrValue::bytes(value)))306	}307308	fn from_untyped(value: Val) -> Result<Self> {309		if let Val::Arr(ArrValue::Bytes(bytes)) = value {310			return Ok(bytes.0);311		}312		<Self as Typed>::TYPE.check(&value)?;313		match value {314			Val::Arr(a) => {315				let mut out = Vec::with_capacity(a.len());316				for e in a.iter() {317					let r = e?;318					out.push(u8::from_untyped(r)?);319				}320				Ok(out.as_slice().into())321			}322			_ => unreachable!(),323		}324	}325}326327pub struct M1;328impl Typed for M1 {329	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));330331	fn into_untyped(_: Self) -> Result<Val> {332		Ok(Val::Num(-1.0))333	}334335	fn from_untyped(value: Val) -> Result<Self> {336		<Self as Typed>::TYPE.check(&value)?;337		Ok(Self)338	}339}340341macro_rules! decl_either {342	($($name: ident, $($id: ident)*);*) => {$(343		#[derive(Clone)]344		pub enum $name<$($id),*> {345			$($id($id)),*346		}347		impl<$($id),*> Typed for $name<$($id),*>348		where349			$($id: Typed,)*350		{351			const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);352353			fn into_untyped(value: Self) -> Result<Val> {354				match value {$(355					$name::$id(v) => $id::into_untyped(v)356				),*}357			}358359			fn from_untyped(value: Val) -> Result<Self> {360				$(361					if $id::TYPE.check(&value).is_ok() {362						$id::from_untyped(value).map(Self::$id)363					} else364				)* {365					<Self as Typed>::TYPE.check(&value)?;366					unreachable!()367				}368			}369		}370	)*}371}372decl_either!(373	Either1, A;374	Either2, A B;375	Either3, A B C;376	Either4, A B C D;377	Either5, A B C D E;378	Either6, A B C D E F;379	Either7, A B C D E F G380);381#[macro_export]382macro_rules! Either {383	($a:ty) => {Either1<$a>};384	($a:ty, $b:ty) => {Either2<$a, $b>};385	($a:ty, $b:ty, $c:ty) => {Either3<$a, $b, $c>};386	($a:ty, $b:ty, $c:ty, $d:ty) => {Either4<$a, $b, $c, $d>};387	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty) => {Either5<$a, $b, $c, $d, $e>};388	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty) => {Either6<$a, $b, $c, $d, $e, $f>};389	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty, $g:ty) => {Either7<$a, $b, $c, $d, $e, $f, $g>};390}391pub use Either;392393pub type MyType = Either![u32, f64, String];394395impl Typed for ArrValue {396	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);397398	fn into_untyped(value: Self) -> Result<Val> {399		Ok(Val::Arr(value))400	}401402	fn from_untyped(value: Val) -> Result<Self> {403		<Self as Typed>::TYPE.check(&value)?;404		match value {405			Val::Arr(a) => Ok(a),406			_ => unreachable!(),407		}408	}409}410411impl Typed for FuncVal {412	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);413414	fn into_untyped(value: Self) -> Result<Val> {415		Ok(Val::Func(value))416	}417418	fn from_untyped(value: Val) -> Result<Self> {419		<Self as Typed>::TYPE.check(&value)?;420		match value {421			Val::Func(a) => Ok(a),422			_ => unreachable!(),423		}424	}425}426427impl Typed for Cc<FuncDesc> {428	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);429430	fn into_untyped(value: Self) -> Result<Val> {431		Ok(Val::Func(FuncVal::Normal(value)))432	}433434	fn from_untyped(value: Val) -> Result<Self> {435		<Self as Typed>::TYPE.check(&value)?;436		match value {437			Val::Func(FuncVal::Normal(desc)) => Ok(desc),438			Val::Func(_) => throw!("expected normal function, not builtin"),439			_ => unreachable!(),440		}441	}442}443444impl Typed for ObjValue {445	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);446447	fn into_untyped(value: Self) -> Result<Val> {448		Ok(Val::Obj(value))449	}450451	fn from_untyped(value: Val) -> Result<Self> {452		<Self as Typed>::TYPE.check(&value)?;453		match value {454			Val::Obj(a) => Ok(a),455			_ => unreachable!(),456		}457	}458}459460impl Typed for bool {461	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);462463	fn into_untyped(value: Self) -> Result<Val> {464		Ok(Val::Bool(value))465	}466467	fn from_untyped(value: Val) -> Result<Self> {468		<Self as Typed>::TYPE.check(&value)?;469		match value {470			Val::Bool(a) => Ok(a),471			_ => unreachable!(),472		}473	}474}475impl Typed for IndexableVal {476	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[477		&ComplexValType::Simple(ValType::Arr),478		&ComplexValType::Simple(ValType::Str),479	]);480481	fn into_untyped(value: Self) -> Result<Val> {482		match value {483			IndexableVal::Str(s) => Ok(Val::Str(StrValue::Flat(s))),484			IndexableVal::Arr(a) => Ok(Val::Arr(a)),485		}486	}487488	fn from_untyped(value: Val) -> Result<Self> {489		<Self as Typed>::TYPE.check(&value)?;490		value.into_indexable()491	}492}493494pub struct Null;495impl Typed for Null {496	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);497498	fn into_untyped(_: Self) -> Result<Val> {499		Ok(Val::Null)500	}501502	fn from_untyped(value: Val) -> Result<Self> {503		<Self as Typed>::TYPE.check(&value)?;504		Ok(Self)505	}506}507508pub struct NativeFn<D: NativeDesc>(D::Value);509impl<D: NativeDesc> Deref for NativeFn<D> {510	type Target = D::Value;511512	fn deref(&self) -> &Self::Target {513		&self.0514	}515}516impl<D: NativeDesc> Typed for NativeFn<D> {517	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);518519	fn into_untyped(_typed: Self) -> Result<Val> {520		throw!("can only convert functions from jsonnet to native")521	}522523	fn from_untyped(untyped: Val) -> Result<Self> {524		Ok(Self(525			untyped526				.as_func()527				.expect("shape is checked")528				.into_native::<D>(),529		))530	}531}