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

1use std::convert::{TryFrom, TryInto};23use gcmodule::Cc;4use jrsonnet_interner::IStr;5use jrsonnet_types::{ComplexValType, ValType};67use crate::{8	error::{Error::*, LocError, Result},9	throw,10	typed::CheckType,11	ArrValue, FuncVal, IndexableVal, ObjValue, Val,12};1314pub trait Typed: TryFrom<Val, Error = LocError> + TryInto<Val, Error = LocError> {15	const TYPE: &'static ComplexValType;16}1718macro_rules! impl_int {19	($($ty:ty)*) => {$(20		impl Typed for $ty {21			const TYPE: &'static ComplexValType =22				&ComplexValType::BoundedNumber(Some(<$ty>::MIN as f64), Some(<$ty>::MAX as f64));23		}24		impl TryFrom<Val> for $ty {25			type Error = LocError;2627			fn try_from(value: Val) -> Result<Self> {28				<Self as Typed>::TYPE.check(&value)?;29				match value {30					Val::Num(n) => {31						if n.trunc() != n {32							throw!(RuntimeError(33								format!(34									"cannot convert number with fractional part to {}",35									stringify!($ty)36								)37								.into()38							))39						}40						Ok(n as Self)41					}42					_ => unreachable!(),43				}44			}45		}46		impl TryFrom<$ty> for Val {47			type Error = LocError;4849			fn try_from(value: $ty) -> Result<Self> {50				Ok(Self::Num(value as f64))51			}52		}53	)*};54}5556impl_int!(i8 u8 i16 u16 i32 u32);5758impl Typed for f64 {59	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);60}61impl TryFrom<Val> for f64 {62	type Error = LocError;6364	fn try_from(value: Val) -> Result<Self> {65		<Self as Typed>::TYPE.check(&value)?;66		match value {67			Val::Num(n) => Ok(n),68			_ => unreachable!(),69		}70	}71}72impl TryFrom<f64> for Val {73	type Error = LocError;7475	fn try_from(value: f64) -> Result<Self> {76		Ok(Self::Num(value))77	}78}7980pub struct PositiveF64(pub f64);81impl Typed for PositiveF64 {82	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);83}84impl TryFrom<Val> for PositiveF64 {85	type Error = LocError;8687	fn try_from(value: Val) -> Result<Self> {88		<Self as Typed>::TYPE.check(&value)?;89		match value {90			Val::Num(n) => Ok(Self(n)),91			_ => unreachable!(),92		}93	}94}95impl TryFrom<PositiveF64> for Val {96	type Error = LocError;9798	fn try_from(value: PositiveF64) -> Result<Self> {99		Ok(Self::Num(value.0))100	}101}102103impl Typed for usize {104	// It is possible to store 54 bits of precision in f64, but leaving u32::MAX here for compatibility105	const TYPE: &'static ComplexValType =106		&ComplexValType::BoundedNumber(Some(0.0), Some(4294967295.0));107}108impl TryFrom<Val> for usize {109	type Error = LocError;110111	fn try_from(value: Val) -> Result<Self> {112		<Self as Typed>::TYPE.check(&value)?;113		match value {114			Val::Num(n) => {115				if n.trunc() != n {116					throw!(RuntimeError(117						"cannot convert number with fractional part to usize".into()118					))119				}120				Ok(n as Self)121			}122			_ => unreachable!(),123		}124	}125}126impl TryFrom<usize> for Val {127	type Error = LocError;128129	fn try_from(value: usize) -> Result<Self> {130		if value > u32::MAX as usize {131			throw!(RuntimeError("number is too large".into()))132		}133		Ok(Self::Num(value as f64))134	}135}136137impl Typed for IStr {138	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);139}140impl TryFrom<Val> for IStr {141	type Error = LocError;142143	fn try_from(value: Val) -> Result<Self> {144		<Self as Typed>::TYPE.check(&value)?;145		match value {146			Val::Str(s) => Ok(s),147			_ => unreachable!(),148		}149	}150}151impl TryFrom<IStr> for Val {152	type Error = LocError;153154	fn try_from(value: IStr) -> Result<Self> {155		Ok(Self::Str(value))156	}157}158159impl Typed for String {160	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);161}162impl TryFrom<Val> for String {163	type Error = LocError;164165	fn try_from(value: Val) -> Result<Self> {166		<Self as Typed>::TYPE.check(&value)?;167		match value {168			Val::Str(s) => Ok(s.to_string()),169			_ => unreachable!(),170		}171	}172}173impl TryFrom<String> for Val {174	type Error = LocError;175176	fn try_from(value: String) -> Result<Self> {177		Ok(Self::Str(value.into()))178	}179}180181impl Typed for char {182	const TYPE: &'static ComplexValType = &ComplexValType::Char;183}184impl TryFrom<Val> for char {185	type Error = LocError;186187	fn try_from(value: Val) -> Result<Self> {188		<Self as Typed>::TYPE.check(&value)?;189		match value {190			Val::Str(s) => Ok(s.chars().next().unwrap()),191			_ => unreachable!(),192		}193	}194}195impl TryFrom<char> for Val {196	type Error = LocError;197198	fn try_from(value: char) -> Result<Self> {199		Ok(Self::Str(value.to_string().into()))200	}201}202203impl<T> Typed for Vec<T>204where205	T: Typed,206	T: TryFrom<Val, Error = LocError>,207	T: TryInto<Val, Error = LocError>,208{209	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);210}211impl<T> TryFrom<Val> for Vec<T>212where213	T: Typed,214	T: TryFrom<Val, Error = LocError>,215	T: TryInto<Val, Error = LocError>,216{217	type Error = LocError;218219	fn try_from(value: Val) -> Result<Self> {220		<Self as Typed>::TYPE.check(&value)?;221		match value {222			Val::Arr(a) => {223				let mut o = Self::with_capacity(a.len());224				for i in a.iter() {225					o.push(T::try_from(i?)?);226				}227				Ok(o)228			}229			_ => unreachable!(),230		}231	}232}233impl<T> TryFrom<Vec<T>> for Val234where235	T: Typed,236	T: TryFrom<Self, Error = LocError>,237	T: TryInto<Self, Error = LocError>,238{239	type Error = LocError;240241	fn try_from(value: Vec<T>) -> Result<Self> {242		let mut o = Vec::with_capacity(value.len());243		for i in value {244			o.push(i.try_into()?);245		}246		Ok(Self::Arr(o.into()))247	}248}249250/// To be used in Vec<Any>251/// Regular Val can't be used here, because it has wrong TryFrom::Error type252#[derive(Clone)]253pub struct Any(pub Val);254255impl Typed for Any {256	const TYPE: &'static ComplexValType = &ComplexValType::Any;257}258impl TryFrom<Val> for Any {259	type Error = LocError;260261	fn try_from(value: Val) -> Result<Self> {262		Ok(Self(value))263	}264}265impl TryFrom<Any> for Val {266	type Error = LocError;267268	fn try_from(value: Any) -> Result<Self> {269		Ok(value.0)270	}271}272273/// Specialization, provides faster TryFrom<VecVal> for Val274pub struct VecVal(pub Vec<Val>);275276impl Typed for VecVal {277	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);278}279impl TryFrom<Val> for VecVal {280	type Error = LocError;281282	fn try_from(value: Val) -> Result<Self> {283		<Self as Typed>::TYPE.check(&value)?;284		match value {285			Val::Arr(a) => Ok(Self(a.evaluated()?.to_vec())),286			_ => unreachable!(),287		}288	}289}290impl TryFrom<VecVal> for Val {291	type Error = LocError;292293	fn try_from(value: VecVal) -> Result<Self> {294		Ok(Self::Arr(value.0.into()))295	}296}297298pub struct M1;299impl Typed for M1 {300	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));301}302impl TryFrom<Val> for M1 {303	type Error = LocError;304305	fn try_from(value: Val) -> Result<Self> {306		<Self as Typed>::TYPE.check(&value)?;307		Ok(Self)308	}309}310impl TryFrom<M1> for Val {311	type Error = LocError;312313	fn try_from(_: M1) -> Result<Self> {314		Ok(Self::Num(-1.0))315	}316}317318macro_rules! decl_either {319	($($name: ident, $($id: ident)*);*) => {$(320		pub enum $name<$($id),*> {321			$($id($id)),*322		}323		impl<$($id),*> Typed for $name<$($id),*>324		where325			$($id: Typed,)*326		{327			const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);328		}329		impl<$($id),*> TryFrom<Val> for $name<$($id),*>330		where331			$($id: Typed,)*332		{333			type Error = LocError;334335			fn try_from(value: Val) -> Result<Self> {336				$(337					if $id::TYPE.check(&value).is_ok() {338						$id::try_from(value).map(Self::$id)339					} else340				)* {341					<Self as Typed>::TYPE.check(&value)?;342					unreachable!()343				}344			}345		}346		impl<$($id),*> TryFrom<$name<$($id),*>> for Val347		where348			$($id: Typed,)*349		{350			type Error = LocError;351			fn try_from(value: $name<$($id),*>) -> Result<Self> {352				match value {$(353					$name::$id(v) => v.try_into()354				),*}355			}356		}357	)*}358}359decl_either!(360	Either1, A;361	Either2, A B;362	Either3, A B C;363	Either4, A B C D;364	Either5, A B C D E;365	Either6, A B C D E F;366	Either7, A B C D E F G367);368#[macro_export]369macro_rules! Either {370	($a:ty) => {Either1<$a>};371	($a:ty, $b:ty) => {Either2<$a, $b>};372	($a:ty, $b:ty, $c:ty) => {Either3<$a, $b, $c>};373	($a:ty, $b:ty, $c:ty, $d:ty) => {Either4<$a, $b, $c, $d>};374	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty) => {Either5<$a, $b, $c, $d, $e>};375	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty) => {Either6<$a, $b, $c, $d, $e, $f>};376	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty, $g:ty) => {Either7<$a, $b, $c, $d, $e, $f, $g>};377}378379pub type MyType = Either![u32, f64, String];380381impl Typed for ArrValue {382	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);383}384impl TryFrom<Val> for ArrValue {385	type Error = LocError;386387	fn try_from(value: Val) -> Result<Self> {388		<Self as Typed>::TYPE.check(&value)?;389		match value {390			Val::Arr(a) => Ok(a),391			_ => unreachable!(),392		}393	}394}395impl TryFrom<ArrValue> for Val {396	type Error = LocError;397398	fn try_from(value: ArrValue) -> Result<Self> {399		Ok(Self::Arr(value))400	}401}402403impl Typed for Cc<FuncVal> {404	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);405}406impl TryFrom<Val> for Cc<FuncVal> {407	type Error = LocError;408409	fn try_from(value: Val) -> Result<Self> {410		<Self as Typed>::TYPE.check(&value)?;411		match value {412			Val::Func(a) => Ok(a),413			_ => unreachable!(),414		}415	}416}417impl TryFrom<Cc<FuncVal>> for Val {418	type Error = LocError;419420	fn try_from(value: Cc<FuncVal>) -> Result<Self> {421		Ok(Self::Func(value))422	}423}424impl Typed for ObjValue {425	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);426}427impl TryFrom<Val> for ObjValue {428	type Error = LocError;429430	fn try_from(value: Val) -> Result<Self> {431		<Self as Typed>::TYPE.check(&value)?;432		match value {433			Val::Obj(a) => Ok(a),434			_ => unreachable!(),435		}436	}437}438impl TryFrom<ObjValue> for Val {439	type Error = LocError;440441	fn try_from(value: ObjValue) -> Result<Self> {442		Ok(Self::Obj(value))443	}444}445446impl Typed for bool {447	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);448}449impl TryFrom<Val> for bool {450	type Error = LocError;451452	fn try_from(value: Val) -> Result<Self> {453		<Self as Typed>::TYPE.check(&value)?;454		match value {455			Val::Bool(a) => Ok(a),456			_ => unreachable!(),457		}458	}459}460impl TryFrom<bool> for Val {461	type Error = LocError;462463	fn try_from(value: bool) -> Result<Self> {464		Ok(Self::Bool(value))465	}466}467468impl Typed for IndexableVal {469	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[470		&ComplexValType::Simple(ValType::Arr),471		&ComplexValType::Simple(ValType::Str),472	]);473}474impl TryFrom<Val> for IndexableVal {475	type Error = LocError;476477	fn try_from(value: Val) -> Result<Self> {478		<Self as Typed>::TYPE.check(&value)?;479		value.into_indexable()480	}481}482impl TryFrom<IndexableVal> for Val {483	type Error = LocError;484485	fn try_from(value: IndexableVal) -> Result<Self> {486		match value {487			IndexableVal::Str(s) => Ok(Self::Str(s)),488			IndexableVal::Arr(a) => Ok(Self::Arr(a)),489		}490	}491}492493pub struct Null;494impl Typed for Null {495	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);496}497impl TryFrom<Val> for Null {498	type Error = LocError;499500	fn try_from(value: Val) -> Result<Self> {501		<Self as Typed>::TYPE.check(&value)?;502		Ok(Self)503	}504}505impl TryFrom<Null> for Val {506	type Error = LocError;507508	fn try_from(_: Null) -> Result<Self> {509		Ok(Self::Null)510	}511}