git.delta.rocks / jrsonnet / refs/commits / efea8379ff42

1use std::convert::{TryFrom, TryInto};23use jrsonnet_interner::IStr;4pub use jrsonnet_macros::Typed;5use jrsonnet_types::{ComplexValType, ValType};67use crate::{8	error::{Error::*, LocError, Result},9	throw,10	typed::CheckType,11	ArrValue, FuncVal, IndexableVal, ObjValue, ObjValueBuilder, Val,12};1314pub trait TypedObj: Typed {15	fn serialize(self, out: &mut ObjValueBuilder) -> Result<()>;16	fn parse(obj: &ObjValue) -> Result<Self>;17	fn into_object(self) -> Result<ObjValue> {18		let mut builder = ObjValueBuilder::new();19		self.serialize(&mut builder)?;20		Ok(builder.build())21	}22}2324pub trait Typed: TryFrom<Val, Error = LocError> + TryInto<Val, Error = LocError> {25	const TYPE: &'static ComplexValType;26}2728macro_rules! impl_int {29	($($ty:ty)*) => {$(30		impl Typed for $ty {31			const TYPE: &'static ComplexValType =32				&ComplexValType::BoundedNumber(Some(Self::MIN as f64), Some(Self::MAX as f64));33		}34		impl TryFrom<Val> for $ty {35			type Error = LocError;3637			fn try_from(value: Val) -> Result<Self> {38				<Self as Typed>::TYPE.check(&value)?;39				match value {40					Val::Num(n) => {41						if n.trunc() != n {42							throw!(RuntimeError(43								format!(44									"cannot convert number with fractional part to {}",45									stringify!($ty)46								)47								.into()48							))49						}50						Ok(n as Self)51					}52					_ => unreachable!(),53				}54			}55		}56		impl TryFrom<$ty> for Val {57			type Error = LocError;5859			fn try_from(value: $ty) -> Result<Self> {60				Ok(Self::Num(value as f64))61			}62		}63	)*};64}6566impl_int!(i8 u8 i16 u16 i32 u32);6768impl Typed for f64 {69	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);70}71impl TryFrom<Val> for f64 {72	type Error = LocError;7374	fn try_from(value: Val) -> Result<Self> {75		<Self as Typed>::TYPE.check(&value)?;76		match value {77			Val::Num(n) => Ok(n),78			_ => unreachable!(),79		}80	}81}82impl TryFrom<f64> for Val {83	type Error = LocError;8485	fn try_from(value: f64) -> Result<Self> {86		Ok(Self::Num(value))87	}88}8990pub struct PositiveF64(pub f64);91impl Typed for PositiveF64 {92	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);93}94impl TryFrom<Val> for PositiveF64 {95	type Error = LocError;9697	fn try_from(value: Val) -> Result<Self> {98		<Self as Typed>::TYPE.check(&value)?;99		match value {100			Val::Num(n) => Ok(Self(n)),101			_ => unreachable!(),102		}103	}104}105impl TryFrom<PositiveF64> for Val {106	type Error = LocError;107108	fn try_from(value: PositiveF64) -> Result<Self> {109		Ok(Self::Num(value.0))110	}111}112113impl Typed for usize {114	// It is possible to store 54 bits of precision in f64, but leaving u32::MAX here for compatibility115	const TYPE: &'static ComplexValType =116		&ComplexValType::BoundedNumber(Some(0.0), Some(4294967295.0));117}118impl TryFrom<Val> for usize {119	type Error = LocError;120121	fn try_from(value: Val) -> Result<Self> {122		<Self as Typed>::TYPE.check(&value)?;123		match value {124			Val::Num(n) => {125				if n.trunc() != n {126					throw!(RuntimeError(127						"cannot convert number with fractional part to usize".into()128					))129				}130				Ok(n as Self)131			}132			_ => unreachable!(),133		}134	}135}136impl TryFrom<usize> for Val {137	type Error = LocError;138139	fn try_from(value: usize) -> Result<Self> {140		if value > u32::MAX as usize {141			throw!(RuntimeError("number is too large".into()))142		}143		Ok(Self::Num(value as f64))144	}145}146147impl Typed for IStr {148	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);149}150impl TryFrom<Val> for IStr {151	type Error = LocError;152153	fn try_from(value: Val) -> Result<Self> {154		<Self as Typed>::TYPE.check(&value)?;155		match value {156			Val::Str(s) => Ok(s),157			_ => unreachable!(),158		}159	}160}161impl TryFrom<IStr> for Val {162	type Error = LocError;163164	fn try_from(value: IStr) -> Result<Self> {165		Ok(Self::Str(value))166	}167}168169impl Typed for String {170	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);171}172impl TryFrom<Val> for String {173	type Error = LocError;174175	fn try_from(value: Val) -> Result<Self> {176		<Self as Typed>::TYPE.check(&value)?;177		match value {178			Val::Str(s) => Ok(s.to_string()),179			_ => unreachable!(),180		}181	}182}183impl TryFrom<String> for Val {184	type Error = LocError;185186	fn try_from(value: String) -> Result<Self> {187		Ok(Self::Str(value.into()))188	}189}190191impl Typed for char {192	const TYPE: &'static ComplexValType = &ComplexValType::Char;193}194impl TryFrom<Val> for char {195	type Error = LocError;196197	fn try_from(value: Val) -> Result<Self> {198		<Self as Typed>::TYPE.check(&value)?;199		match value {200			Val::Str(s) => Ok(s.chars().next().unwrap()),201			_ => unreachable!(),202		}203	}204}205impl TryFrom<char> for Val {206	type Error = LocError;207208	fn try_from(value: char) -> Result<Self> {209		Ok(Self::Str(value.to_string().into()))210	}211}212213impl<T> Typed for Vec<T>214where215	T: Typed,216	T: TryFrom<Val, Error = LocError>,217	T: TryInto<Val, Error = LocError>,218{219	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);220}221impl<T> TryFrom<Val> for Vec<T>222where223	T: Typed,224	T: TryFrom<Val, Error = LocError>,225	T: TryInto<Val, Error = LocError>,226{227	type Error = LocError;228229	fn try_from(value: Val) -> Result<Self> {230		<Self as Typed>::TYPE.check(&value)?;231		match value {232			Val::Arr(a) => {233				let mut o = Self::with_capacity(a.len());234				for i in a.iter() {235					o.push(T::try_from(i?)?);236				}237				Ok(o)238			}239			_ => unreachable!(),240		}241	}242}243impl<T> TryFrom<Vec<T>> for Val244where245	T: Typed,246	T: TryFrom<Self, Error = LocError>,247	T: TryInto<Self, Error = LocError>,248{249	type Error = LocError;250251	fn try_from(value: Vec<T>) -> Result<Self> {252		let mut o = Vec::with_capacity(value.len());253		for i in value {254			o.push(i.try_into()?);255		}256		Ok(Self::Arr(o.into()))257	}258}259260/// To be used in Vec<Any>261/// Regular Val can't be used here, because it has wrong TryFrom::Error type262#[derive(Clone)]263pub struct Any(pub Val);264265impl Typed for Any {266	const TYPE: &'static ComplexValType = &ComplexValType::Any;267}268impl TryFrom<Val> for Any {269	type Error = LocError;270271	fn try_from(value: Val) -> Result<Self> {272		Ok(Self(value))273	}274}275impl TryFrom<Any> for Val {276	type Error = LocError;277278	fn try_from(value: Any) -> Result<Self> {279		Ok(value.0)280	}281}282283/// Specialization, provides faster TryFrom<VecVal> for Val284pub struct VecVal(pub Vec<Val>);285286impl Typed for VecVal {287	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);288}289impl TryFrom<Val> for VecVal {290	type Error = LocError;291292	fn try_from(value: Val) -> Result<Self> {293		<Self as Typed>::TYPE.check(&value)?;294		match value {295			Val::Arr(a) => Ok(Self(a.evaluated()?.to_vec())),296			_ => unreachable!(),297		}298	}299}300impl TryFrom<VecVal> for Val {301	type Error = LocError;302303	fn try_from(value: VecVal) -> Result<Self> {304		Ok(Self::Arr(value.0.into()))305	}306}307308pub struct M1;309impl Typed for M1 {310	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));311}312impl TryFrom<Val> for M1 {313	type Error = LocError;314315	fn try_from(value: Val) -> Result<Self> {316		<Self as Typed>::TYPE.check(&value)?;317		Ok(Self)318	}319}320impl TryFrom<M1> for Val {321	type Error = LocError;322323	fn try_from(_: M1) -> Result<Self> {324		Ok(Self::Num(-1.0))325	}326}327328macro_rules! decl_either {329	($($name: ident, $($id: ident)*);*) => {$(330		pub enum $name<$($id),*> {331			$($id($id)),*332		}333		impl<$($id),*> Typed for $name<$($id),*>334		where335			$($id: Typed,)*336		{337			const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);338		}339		impl<$($id),*> TryFrom<Val> for $name<$($id),*>340		where341			$($id: Typed,)*342		{343			type Error = LocError;344345			fn try_from(value: Val) -> Result<Self> {346				$(347					if $id::TYPE.check(&value).is_ok() {348						$id::try_from(value).map(Self::$id)349					} else350				)* {351					<Self as Typed>::TYPE.check(&value)?;352					unreachable!()353				}354			}355		}356		impl<$($id),*> TryFrom<$name<$($id),*>> for Val357		where358			$($id: Typed,)*359		{360			type Error = LocError;361			fn try_from(value: $name<$($id),*>) -> Result<Self> {362				match value {$(363					$name::$id(v) => v.try_into()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}388389pub type MyType = Either![u32, f64, String];390391impl Typed for ArrValue {392	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);393}394impl TryFrom<Val> for ArrValue {395	type Error = LocError;396397	fn try_from(value: Val) -> Result<Self> {398		<Self as Typed>::TYPE.check(&value)?;399		match value {400			Val::Arr(a) => Ok(a),401			_ => unreachable!(),402		}403	}404}405impl TryFrom<ArrValue> for Val {406	type Error = LocError;407408	fn try_from(value: ArrValue) -> Result<Self> {409		Ok(Self::Arr(value))410	}411}412413impl Typed for FuncVal {414	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);415}416impl TryFrom<Val> for FuncVal {417	type Error = LocError;418419	fn try_from(value: Val) -> Result<Self> {420		<Self as Typed>::TYPE.check(&value)?;421		match value {422			Val::Func(a) => Ok(a),423			_ => unreachable!(),424		}425	}426}427impl TryFrom<FuncVal> for Val {428	type Error = LocError;429430	fn try_from(value: FuncVal) -> Result<Self> {431		Ok(Self::Func(value))432	}433}434impl Typed for ObjValue {435	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);436}437impl TryFrom<Val> for ObjValue {438	type Error = LocError;439440	fn try_from(value: Val) -> Result<Self> {441		<Self as Typed>::TYPE.check(&value)?;442		match value {443			Val::Obj(a) => Ok(a),444			_ => unreachable!(),445		}446	}447}448impl TryFrom<ObjValue> for Val {449	type Error = LocError;450451	fn try_from(value: ObjValue) -> Result<Self> {452		Ok(Self::Obj(value))453	}454}455456impl Typed for bool {457	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);458}459impl TryFrom<Val> for bool {460	type Error = LocError;461462	fn try_from(value: Val) -> Result<Self> {463		<Self as Typed>::TYPE.check(&value)?;464		match value {465			Val::Bool(a) => Ok(a),466			_ => unreachable!(),467		}468	}469}470impl TryFrom<bool> for Val {471	type Error = LocError;472473	fn try_from(value: bool) -> Result<Self> {474		Ok(Self::Bool(value))475	}476}477478impl Typed for IndexableVal {479	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[480		&ComplexValType::Simple(ValType::Arr),481		&ComplexValType::Simple(ValType::Str),482	]);483}484impl TryFrom<Val> for IndexableVal {485	type Error = LocError;486487	fn try_from(value: Val) -> Result<Self> {488		<Self as Typed>::TYPE.check(&value)?;489		value.into_indexable()490	}491}492impl TryFrom<IndexableVal> for Val {493	type Error = LocError;494495	fn try_from(value: IndexableVal) -> Result<Self> {496		match value {497			IndexableVal::Str(s) => Ok(Self::Str(s)),498			IndexableVal::Arr(a) => Ok(Self::Arr(a)),499		}500	}501}502503pub struct Null;504impl Typed for Null {505	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);506}507impl TryFrom<Val> for Null {508	type Error = LocError;509510	fn try_from(value: Val) -> Result<Self> {511		<Self as Typed>::TYPE.check(&value)?;512		Ok(Self)513	}514}515impl TryFrom<Null> for Val {516	type Error = LocError;517518	fn try_from(_: Null) -> Result<Self> {519		Ok(Self::Null)520	}521}