git.delta.rocks / jrsonnet / refs/commits / 5e6d5ee048e2

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	error::Result,10	function::{FuncDesc, FuncVal},11	throw,12	typed::CheckType,13	val::{ArrValue, IndexableVal},14	ObjValue, ObjValueBuilder, State, Val,15};1617pub trait TypedObj: Typed {18	fn serialize(self, s: State, out: &mut ObjValueBuilder) -> Result<()>;19	fn parse(obj: &ObjValue, s: State) -> Result<Self>;20	fn into_object(self, s: State) -> Result<ObjValue> {21		let mut builder = ObjValueBuilder::new();22		self.serialize(s, &mut builder)?;23		Ok(builder.build())24	}25}2627pub trait Typed: Sized {28	const TYPE: &'static ComplexValType;29	fn into_untyped(typed: Self, s: State) -> Result<Val>;30	fn from_untyped(untyped: Val, s: State) -> Result<Self>;31}3233macro_rules! impl_int {34	($($ty:ty)*) => {$(35		impl Typed for $ty {36			const TYPE: &'static ComplexValType =37				&ComplexValType::BoundedNumber(Some(Self::MIN as f64), Some(Self::MAX as f64));38			fn from_untyped(value: Val, s: State) -> Result<Self> {39				<Self as Typed>::TYPE.check(s, &value)?;40				match value {41					Val::Num(n) => {42						#[allow(clippy::float_cmp)]43						if n.trunc() != n {44							throw!(45								"cannot convert number with fractional part to {}",46								stringify!($ty)47							)48						}49						Ok(n as Self)50					}51					_ => unreachable!(),52				}53			}54			fn into_untyped(value: Self, _: State) -> Result<Val> {55				Ok(Val::Num(value as f64))56			}57		}58	)*};59}6061impl_int!(i8 u8 i16 u16 i32 u32);6263macro_rules! impl_bounded_int {64	($($name:ident = $ty:ty)*) => {$(65		#[derive(Clone, Copy)]66		pub struct $name<const MIN: $ty, const MAX: $ty>($ty);67		impl<const MIN: $ty, const MAX: $ty> $name<MIN, MAX> {68			pub const fn new(value: $ty) -> Option<$name<MIN, MAX>> {69				if value >= MIN && value <= MAX {70					Some(Self(value))71				} else {72					None73				}74			}75			pub const fn value(self) -> $ty {76				self.077			}78		}79		impl<const MIN: $ty, const MAX: $ty> Deref for $name<MIN, MAX> {80			type Target = $ty;81			fn deref(&self) -> &Self::Target {82				&self.083			}84		}8586		impl<const MIN: $ty, const MAX: $ty> Typed for $name<MIN, MAX> {87			const TYPE: &'static ComplexValType =88				&ComplexValType::BoundedNumber(89					Some(MIN as f64),90					Some(MAX as f64),91				);9293			fn from_untyped(value: Val, s: State) -> Result<Self> {94				<Self as Typed>::TYPE.check(s, &value)?;95				match value {96					Val::Num(n) => {97						#[allow(clippy::float_cmp)]98						if n.trunc() != n {99							throw!(100								"cannot convert number with fractional part to {}",101								stringify!($ty)102							)103						}104						Ok(Self(n as $ty))105					}106					_ => unreachable!(),107				}108			}109110			fn into_untyped(value: Self, _: State) -> Result<Val> {111				Ok(Val::Num(value.0 as f64))112			}113		}114	)*};115}116117impl_bounded_int!(118	BoundedI8 = i8119	BoundedI16 = i16120	BoundedI32 = i32121	BoundedI64 = i64122	BoundedUsize = usize123);124125impl Typed for f64 {126	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);127128	fn into_untyped(value: Self, _: State) -> Result<Val> {129		Ok(Val::Num(value))130	}131132	fn from_untyped(value: Val, s: State) -> Result<Self> {133		<Self as Typed>::TYPE.check(s, &value)?;134		match value {135			Val::Num(n) => Ok(n),136			_ => unreachable!(),137		}138	}139}140141pub struct PositiveF64(pub f64);142impl Typed for PositiveF64 {143	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);144145	fn into_untyped(value: Self, _: State) -> Result<Val> {146		Ok(Val::Num(value.0))147	}148149	fn from_untyped(value: Val, s: State) -> Result<Self> {150		<Self as Typed>::TYPE.check(s, &value)?;151		match value {152			Val::Num(n) => Ok(Self(n)),153			_ => unreachable!(),154		}155	}156}157impl Typed for usize {158	// It is possible to store 54 bits of precision in f64, but leaving u32::MAX here for compatibility159	const TYPE: &'static ComplexValType =160		&ComplexValType::BoundedNumber(Some(0.0), Some(u32::MAX as f64));161162	fn into_untyped(value: Self, _: State) -> Result<Val> {163		if value > u32::MAX as Self {164			throw!("number is too large")165		}166		Ok(Val::Num(value as f64))167	}168169	fn from_untyped(value: Val, s: State) -> Result<Self> {170		<Self as Typed>::TYPE.check(s, &value)?;171		match value {172			Val::Num(n) => {173				#[allow(clippy::float_cmp)]174				if n.trunc() != n {175					throw!("cannot convert number with fractional part to usize")176				}177				Ok(n as Self)178			}179			_ => unreachable!(),180		}181	}182}183184impl Typed for IStr {185	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);186187	fn into_untyped(value: Self, _: State) -> Result<Val> {188		Ok(Val::Str(value))189	}190191	fn from_untyped(value: Val, s: State) -> Result<Self> {192		<Self as Typed>::TYPE.check(s, &value)?;193		match value {194			Val::Str(s) => Ok(s),195			_ => unreachable!(),196		}197	}198}199200impl Typed for String {201	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);202203	fn into_untyped(value: Self, _: State) -> Result<Val> {204		Ok(Val::Str(value.into()))205	}206207	fn from_untyped(value: Val, s: State) -> Result<Self> {208		<Self as Typed>::TYPE.check(s, &value)?;209		match value {210			Val::Str(s) => Ok(s.to_string()),211			_ => unreachable!(),212		}213	}214}215216impl Typed for char {217	const TYPE: &'static ComplexValType = &ComplexValType::Char;218219	fn into_untyped(value: Self, _: State) -> Result<Val> {220		Ok(Val::Str(value.to_string().into()))221	}222223	fn from_untyped(value: Val, s: State) -> Result<Self> {224		<Self as Typed>::TYPE.check(s, &value)?;225		match value {226			Val::Str(s) => Ok(s.chars().next().unwrap()),227			_ => unreachable!(),228		}229	}230}231232impl<T> Typed for Vec<T>233where234	T: Typed,235{236	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);237238	fn into_untyped(value: Self, s: State) -> Result<Val> {239		let mut o = Vec::with_capacity(value.len());240		for i in value {241			o.push(T::into_untyped(i, s.clone())?);242		}243		Ok(Val::Arr(o.into()))244	}245246	fn from_untyped(value: Val, s: State) -> Result<Self> {247		<Self as Typed>::TYPE.check(s.clone(), &value)?;248		match value {249			Val::Arr(a) => {250				let mut o = Self::with_capacity(a.len());251				for i in a.iter(s.clone()) {252					o.push(T::from_untyped(i?, s.clone())?);253				}254				Ok(o)255			}256			_ => unreachable!(),257		}258	}259}260261/// To be used in Vec<Any>262/// Regular Val can't be used here, because it has wrong `TryFrom::Error` type263#[derive(Clone)]264pub struct Any(pub Val);265266impl Typed for Any {267	const TYPE: &'static ComplexValType = &ComplexValType::Any;268269	fn into_untyped(value: Self, _: State) -> Result<Val> {270		Ok(value.0)271	}272273	fn from_untyped(value: Val, _: State) -> Result<Self> {274		Ok(Self(value))275	}276}277278/// Specialization, provides faster `TryFrom<VecVal>` for Val279pub struct VecVal(pub Cc<Vec<Val>>);280281impl Typed for VecVal {282	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);283284	fn into_untyped(value: Self, _: State) -> Result<Val> {285		Ok(Val::Arr(ArrValue::Eager(value.0)))286	}287288	fn from_untyped(value: Val, s: State) -> Result<Self> {289		<Self as Typed>::TYPE.check(s.clone(), &value)?;290		match value {291			Val::Arr(a) => Ok(Self(a.evaluated(s)?)),292			_ => unreachable!(),293		}294	}295}296297/// Specialization298impl Typed for IBytes {299	const TYPE: &'static ComplexValType =300		&ComplexValType::ArrayRef(&ComplexValType::BoundedNumber(Some(0.0), Some(255.0)));301302	fn into_untyped(value: Self, _: State) -> Result<Val> {303		Ok(Val::Arr(ArrValue::Bytes(value)))304	}305306	fn from_untyped(value: Val, s: State) -> Result<Self> {307		if let Val::Arr(ArrValue::Bytes(bytes)) = value {308			return Ok(bytes);309		}310		<Self as Typed>::TYPE.check(s.clone(), &value)?;311		match value {312			Val::Arr(a) => {313				let mut out = Vec::with_capacity(a.len());314				for e in a.iter(s.clone()) {315					let r = e?;316					out.push(u8::from_untyped(r, s.clone())?);317				}318				Ok(out.as_slice().into())319			}320			_ => unreachable!(),321		}322	}323}324325pub struct M1;326impl Typed for M1 {327	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));328329	fn into_untyped(_: Self, _: State) -> Result<Val> {330		Ok(Val::Num(-1.0))331	}332333	fn from_untyped(value: Val, s: State) -> Result<Self> {334		<Self as Typed>::TYPE.check(s, &value)?;335		Ok(Self)336	}337}338339macro_rules! decl_either {340	($($name: ident, $($id: ident)*);*) => {$(341		pub enum $name<$($id),*> {342			$($id($id)),*343		}344		impl<$($id),*> Typed for $name<$($id),*>345		where346			$($id: Typed,)*347		{348			const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);349350			fn into_untyped(value: Self, s: State) -> Result<Val> {351				match value {$(352					$name::$id(v) => $id::into_untyped(v, s)353				),*}354			}355356			fn from_untyped(value: Val, s: State) -> Result<Self> {357				$(358					if $id::TYPE.check(s.clone(), &value).is_ok() {359						$id::from_untyped(value, s.clone()).map(Self::$id)360					} else361				)* {362					<Self as Typed>::TYPE.check(s, &value)?;363					unreachable!()364				}365			}366		}367	)*}368}369decl_either!(370	Either1, A;371	Either2, A B;372	Either3, A B C;373	Either4, A B C D;374	Either5, A B C D E;375	Either6, A B C D E F;376	Either7, A B C D E F G377);378#[macro_export]379macro_rules! Either {380	($a:ty) => {Either1<$a>};381	($a:ty, $b:ty) => {Either2<$a, $b>};382	($a:ty, $b:ty, $c:ty) => {Either3<$a, $b, $c>};383	($a:ty, $b:ty, $c:ty, $d:ty) => {Either4<$a, $b, $c, $d>};384	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty) => {Either5<$a, $b, $c, $d, $e>};385	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty) => {Either6<$a, $b, $c, $d, $e, $f>};386	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty, $g:ty) => {Either7<$a, $b, $c, $d, $e, $f, $g>};387}388pub use Either;389390pub type MyType = Either![u32, f64, String];391392impl Typed for ArrValue {393	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);394395	fn into_untyped(value: Self, _: State) -> Result<Val> {396		Ok(Val::Arr(value))397	}398399	fn from_untyped(value: Val, s: State) -> Result<Self> {400		<Self as Typed>::TYPE.check(s, &value)?;401		match value {402			Val::Arr(a) => Ok(a),403			_ => unreachable!(),404		}405	}406}407408impl Typed for FuncVal {409	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);410411	fn into_untyped(value: Self, _: State) -> Result<Val> {412		Ok(Val::Func(value))413	}414415	fn from_untyped(value: Val, s: State) -> Result<Self> {416		<Self as Typed>::TYPE.check(s, &value)?;417		match value {418			Val::Func(a) => Ok(a),419			_ => unreachable!(),420		}421	}422}423424impl Typed for Cc<FuncDesc> {425	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);426427	fn into_untyped(value: Self, _: State) -> Result<Val> {428		Ok(Val::Func(FuncVal::Normal(value)))429	}430431	fn from_untyped(value: Val, s: State) -> Result<Self> {432		<Self as Typed>::TYPE.check(s, &value)?;433		match value {434			Val::Func(FuncVal::Normal(desc)) => Ok(desc),435			Val::Func(_) => throw!("expected normal function, not builtin"),436			_ => unreachable!(),437		}438	}439}440441impl Typed for ObjValue {442	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);443444	fn into_untyped(value: Self, _: State) -> Result<Val> {445		Ok(Val::Obj(value))446	}447448	fn from_untyped(value: Val, s: State) -> Result<Self> {449		<Self as Typed>::TYPE.check(s, &value)?;450		match value {451			Val::Obj(a) => Ok(a),452			_ => unreachable!(),453		}454	}455}456457impl Typed for bool {458	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);459460	fn into_untyped(value: Self, _: State) -> Result<Val> {461		Ok(Val::Bool(value))462	}463464	fn from_untyped(value: Val, s: State) -> Result<Self> {465		<Self as Typed>::TYPE.check(s, &value)?;466		match value {467			Val::Bool(a) => Ok(a),468			_ => unreachable!(),469		}470	}471}472impl Typed for IndexableVal {473	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[474		&ComplexValType::Simple(ValType::Arr),475		&ComplexValType::Simple(ValType::Str),476	]);477478	fn into_untyped(value: Self, _: State) -> Result<Val> {479		match value {480			IndexableVal::Str(s) => Ok(Val::Str(s)),481			IndexableVal::Arr(a) => Ok(Val::Arr(a)),482		}483	}484485	fn from_untyped(value: Val, s: State) -> Result<Self> {486		<Self as Typed>::TYPE.check(s, &value)?;487		value.into_indexable()488	}489}490491pub struct Null;492impl Typed for Null {493	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);494495	fn into_untyped(_: Self, _: State) -> Result<Val> {496		Ok(Val::Null)497	}498499	fn from_untyped(value: Val, s: State) -> Result<Self> {500		<Self as Typed>::TYPE.check(s, &value)?;501		Ok(Self)502	}503}