git.delta.rocks / jrsonnet / refs/commits / 4c008687f967

1use std::{2	convert::{TryFrom, TryInto},3	ops::Deref,4	rc::Rc,5};67use gcmodule::Cc;8use jrsonnet_interner::IStr;9pub use jrsonnet_macros::Typed;10use jrsonnet_types::{ComplexValType, ValType};1112use crate::{13	error::{Error::*, LocError, Result},14	throw,15	typed::CheckType,16	val::{ArrValue, FuncDesc, FuncVal, IndexableVal},17	ObjValue, ObjValueBuilder, Val,18};1920pub trait TypedObj: Typed {21	fn serialize(self, out: &mut ObjValueBuilder) -> Result<()>;22	fn parse(obj: &ObjValue) -> Result<Self>;23	fn into_object(self) -> Result<ObjValue> {24		let mut builder = ObjValueBuilder::new();25		self.serialize(&mut builder)?;26		Ok(builder.build())27	}28}2930pub trait Typed: TryFrom<Val, Error = LocError> + TryInto<Val, Error = LocError> {31	const TYPE: &'static ComplexValType;32}3334macro_rules! impl_int {35	($($ty:ty)*) => {$(36		impl Typed for $ty {37			const TYPE: &'static ComplexValType =38				&ComplexValType::BoundedNumber(Some(Self::MIN as f64), Some(Self::MAX as f64));39		}40		impl TryFrom<Val> for $ty {41			type Error = LocError;4243			fn try_from(value: Val) -> Result<Self> {44				<Self as Typed>::TYPE.check(&value)?;45				match value {46					Val::Num(n) => {47						if n.trunc() != n {48							throw!(RuntimeError(49								format!(50									"cannot convert number with fractional part to {}",51									stringify!($ty)52								)53								.into()54							))55						}56						Ok(n as Self)57					}58					_ => unreachable!(),59				}60			}61		}62		impl TryFrom<$ty> for Val {63			type Error = LocError;6465			fn try_from(value: $ty) -> Result<Self> {66				Ok(Self::Num(value as f64))67			}68		}69	)*};70}7172impl_int!(i8 u8 i16 u16 i32 u32);7374macro_rules! impl_bounded_int {75	($($name:ident = $ty:ty)*) => {$(76		#[derive(Clone, Copy)]77		pub struct $name<const MIN: $ty, const MAX: $ty>($ty);78		impl<const MIN: $ty, const MAX: $ty> $name<MIN, MAX> {79			pub const fn new(value: $ty) -> Option<$name<MIN, MAX>> {80				if value >= MIN && value <= MAX {81					Some(Self(value))82				} else {83					None84				}85			}86			pub const fn value(self) -> $ty {87				self.088			}89		}90		impl<const MIN: $ty, const MAX: $ty> Deref for $name<MIN, MAX> {91			type Target = $ty;92			fn deref(&self) -> &Self::Target {93				&self.094			}95		}9697		impl<const MIN: $ty, const MAX: $ty> Typed for $name<MIN, MAX> {98			const TYPE: &'static ComplexValType =99				&ComplexValType::BoundedNumber(100					Some(MIN as f64),101					Some(MAX as f64),102				);103		}104		impl<const MIN: $ty, const MAX: $ty> TryFrom<Val> for $name<MIN, MAX> {105			type Error = LocError;106107			fn try_from(value: Val) -> Result<Self> {108				<Self as Typed>::TYPE.check(&value)?;109				match value {110					Val::Num(n) => {111						if n.trunc() != n {112							throw!(RuntimeError(113								format!(114									"cannot convert number with fractional part to {}",115									stringify!($ty)116								)117								.into()118							))119						}120						Ok(Self(n as $ty))121					}122					_ => unreachable!(),123				}124			}125		}126		impl<const MIN: $ty, const MAX: $ty> TryFrom<$name<MIN, MAX>> for Val {127			type Error = LocError;128129			fn try_from(value: $name<MIN, MAX>) -> Result<Self> {130				Ok(Self::Num(value.0 as f64))131			}132		}133	)*};134}135136impl_bounded_int!(137	BoundedI8 = i8138	BoundedI16 = i16139	BoundedI32 = i32140	BoundedI64 = i64141	BoundedUsize = usize142);143144impl Typed for f64 {145	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);146}147impl TryFrom<Val> for f64 {148	type Error = LocError;149150	fn try_from(value: Val) -> Result<Self> {151		<Self as Typed>::TYPE.check(&value)?;152		match value {153			Val::Num(n) => Ok(n),154			_ => unreachable!(),155		}156	}157}158impl TryFrom<f64> for Val {159	type Error = LocError;160161	fn try_from(value: f64) -> Result<Self> {162		Ok(Self::Num(value))163	}164}165166pub struct PositiveF64(pub f64);167impl Typed for PositiveF64 {168	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);169}170impl TryFrom<Val> for PositiveF64 {171	type Error = LocError;172173	fn try_from(value: Val) -> Result<Self> {174		<Self as Typed>::TYPE.check(&value)?;175		match value {176			Val::Num(n) => Ok(Self(n)),177			_ => unreachable!(),178		}179	}180}181impl TryFrom<PositiveF64> for Val {182	type Error = LocError;183184	fn try_from(value: PositiveF64) -> Result<Self> {185		Ok(Self::Num(value.0))186	}187}188189impl Typed for usize {190	// It is possible to store 54 bits of precision in f64, but leaving u32::MAX here for compatibility191	const TYPE: &'static ComplexValType =192		&ComplexValType::BoundedNumber(Some(0.0), Some(4294967295.0));193}194impl TryFrom<Val> for usize {195	type Error = LocError;196197	fn try_from(value: Val) -> Result<Self> {198		<Self as Typed>::TYPE.check(&value)?;199		match value {200			Val::Num(n) => {201				if n.trunc() != n {202					throw!(RuntimeError(203						"cannot convert number with fractional part to usize".into()204					))205				}206				Ok(n as Self)207			}208			_ => unreachable!(),209		}210	}211}212impl TryFrom<usize> for Val {213	type Error = LocError;214215	fn try_from(value: usize) -> Result<Self> {216		if value > u32::MAX as usize {217			throw!(RuntimeError("number is too large".into()))218		}219		Ok(Self::Num(value as f64))220	}221}222223impl Typed for IStr {224	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);225}226impl TryFrom<Val> for IStr {227	type Error = LocError;228229	fn try_from(value: Val) -> Result<Self> {230		<Self as Typed>::TYPE.check(&value)?;231		match value {232			Val::Str(s) => Ok(s),233			_ => unreachable!(),234		}235	}236}237impl TryFrom<IStr> for Val {238	type Error = LocError;239240	fn try_from(value: IStr) -> Result<Self> {241		Ok(Self::Str(value))242	}243}244245impl Typed for String {246	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);247}248impl TryFrom<Val> for String {249	type Error = LocError;250251	fn try_from(value: Val) -> Result<Self> {252		<Self as Typed>::TYPE.check(&value)?;253		match value {254			Val::Str(s) => Ok(s.to_string()),255			_ => unreachable!(),256		}257	}258}259impl TryFrom<String> for Val {260	type Error = LocError;261262	fn try_from(value: String) -> Result<Self> {263		Ok(Self::Str(value.into()))264	}265}266267impl Typed for char {268	const TYPE: &'static ComplexValType = &ComplexValType::Char;269}270impl TryFrom<Val> for char {271	type Error = LocError;272273	fn try_from(value: Val) -> Result<Self> {274		<Self as Typed>::TYPE.check(&value)?;275		match value {276			Val::Str(s) => Ok(s.chars().next().unwrap()),277			_ => unreachable!(),278		}279	}280}281impl TryFrom<char> for Val {282	type Error = LocError;283284	fn try_from(value: char) -> Result<Self> {285		Ok(Self::Str(value.to_string().into()))286	}287}288289impl<T> Typed for Vec<T>290where291	T: Typed,292	T: TryFrom<Val, Error = LocError>,293	T: TryInto<Val, Error = LocError>,294{295	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);296}297impl<T> TryFrom<Val> for Vec<T>298where299	T: Typed,300	T: TryFrom<Val, Error = LocError>,301	T: TryInto<Val, Error = LocError>,302{303	type Error = LocError;304305	fn try_from(value: Val) -> Result<Self> {306		<Self as Typed>::TYPE.check(&value)?;307		match value {308			Val::Arr(a) => {309				let mut o = Self::with_capacity(a.len());310				for i in a.iter() {311					o.push(T::try_from(i?)?);312				}313				Ok(o)314			}315			_ => unreachable!(),316		}317	}318}319impl<T> TryFrom<Vec<T>> for Val320where321	T: Typed,322	T: TryFrom<Self, Error = LocError>,323	T: TryInto<Self, Error = LocError>,324{325	type Error = LocError;326327	fn try_from(value: Vec<T>) -> Result<Self> {328		let mut o = Vec::with_capacity(value.len());329		for i in value {330			o.push(i.try_into()?);331		}332		Ok(Self::Arr(o.into()))333	}334}335336/// To be used in Vec<Any>337/// Regular Val can't be used here, because it has wrong TryFrom::Error type338#[derive(Clone)]339pub struct Any(pub Val);340341impl Typed for Any {342	const TYPE: &'static ComplexValType = &ComplexValType::Any;343}344impl TryFrom<Val> for Any {345	type Error = LocError;346347	fn try_from(value: Val) -> Result<Self> {348		Ok(Self(value))349	}350}351impl TryFrom<Any> for Val {352	type Error = LocError;353354	fn try_from(value: Any) -> Result<Self> {355		Ok(value.0)356	}357}358359/// Specialization, provides faster TryFrom<VecVal> for Val360pub struct VecVal(pub Cc<Vec<Val>>);361362impl Typed for VecVal {363	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);364}365impl TryFrom<Val> for VecVal {366	type Error = LocError;367368	fn try_from(value: Val) -> Result<Self> {369		<Self as Typed>::TYPE.check(&value)?;370		match value {371			Val::Arr(a) => Ok(Self(a.evaluated()?)),372			_ => unreachable!(),373		}374	}375}376impl TryFrom<VecVal> for Val {377	type Error = LocError;378379	fn try_from(value: VecVal) -> Result<Self> {380		Ok(Self::Arr(ArrValue::Eager(value.0)))381	}382}383384/// Specialization385pub struct Bytes(pub Rc<[u8]>);386387impl Typed for Bytes {388	const TYPE: &'static ComplexValType =389		&ComplexValType::ArrayRef(&ComplexValType::BoundedNumber(Some(0.0), Some(255.0)));390}391impl TryFrom<Val> for Bytes {392	type Error = LocError;393394	fn try_from(value: Val) -> Result<Self> {395		match value {396			Val::Arr(ArrValue::Bytes(bytes)) => Ok(Self(bytes)),397			_ => {398				<Self as Typed>::TYPE.check(&value)?;399				match value {400					Val::Arr(a) => {401						let mut out = Vec::with_capacity(a.len());402						for e in a.iter() {403							let r = e?;404							out.push(u8::try_from(r)?);405						}406						Ok(Self(out.into()))407					}408					_ => unreachable!(),409				}410			}411		}412	}413}414impl TryFrom<Bytes> for Val {415	type Error = LocError;416417	fn try_from(value: Bytes) -> Result<Self> {418		Ok(Self::Arr(ArrValue::Bytes(value.0)))419	}420}421422pub struct M1;423impl Typed for M1 {424	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));425}426impl TryFrom<Val> for M1 {427	type Error = LocError;428429	fn try_from(value: Val) -> Result<Self> {430		<Self as Typed>::TYPE.check(&value)?;431		Ok(Self)432	}433}434impl TryFrom<M1> for Val {435	type Error = LocError;436437	fn try_from(_: M1) -> Result<Self> {438		Ok(Self::Num(-1.0))439	}440}441442macro_rules! decl_either {443	($($name: ident, $($id: ident)*);*) => {$(444		pub enum $name<$($id),*> {445			$($id($id)),*446		}447		impl<$($id),*> Typed for $name<$($id),*>448		where449			$($id: Typed,)*450		{451			const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);452		}453		impl<$($id),*> TryFrom<Val> for $name<$($id),*>454		where455			$($id: Typed,)*456		{457			type Error = LocError;458459			fn try_from(value: Val) -> Result<Self> {460				$(461					if $id::TYPE.check(&value).is_ok() {462						$id::try_from(value).map(Self::$id)463					} else464				)* {465					<Self as Typed>::TYPE.check(&value)?;466					unreachable!()467				}468			}469		}470		impl<$($id),*> TryFrom<$name<$($id),*>> for Val471		where472			$($id: Typed,)*473		{474			type Error = LocError;475			fn try_from(value: $name<$($id),*>) -> Result<Self> {476				match value {$(477					$name::$id(v) => v.try_into()478				),*}479			}480		}481	)*}482}483decl_either!(484	Either1, A;485	Either2, A B;486	Either3, A B C;487	Either4, A B C D;488	Either5, A B C D E;489	Either6, A B C D E F;490	Either7, A B C D E F G491);492#[macro_export]493macro_rules! Either {494	($a:ty) => {Either1<$a>};495	($a:ty, $b:ty) => {Either2<$a, $b>};496	($a:ty, $b:ty, $c:ty) => {Either3<$a, $b, $c>};497	($a:ty, $b:ty, $c:ty, $d:ty) => {Either4<$a, $b, $c, $d>};498	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty) => {Either5<$a, $b, $c, $d, $e>};499	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty) => {Either6<$a, $b, $c, $d, $e, $f>};500	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty, $g:ty) => {Either7<$a, $b, $c, $d, $e, $f, $g>};501}502503pub type MyType = Either![u32, f64, String];504505impl Typed for ArrValue {506	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);507}508impl TryFrom<Val> for ArrValue {509	type Error = LocError;510511	fn try_from(value: Val) -> Result<Self> {512		<Self as Typed>::TYPE.check(&value)?;513		match value {514			Val::Arr(a) => Ok(a),515			_ => unreachable!(),516		}517	}518}519impl TryFrom<ArrValue> for Val {520	type Error = LocError;521522	fn try_from(value: ArrValue) -> Result<Self> {523		Ok(Self::Arr(value))524	}525}526527impl Typed for FuncVal {528	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);529}530impl TryFrom<Val> for FuncVal {531	type Error = LocError;532533	fn try_from(value: Val) -> Result<Self> {534		<Self as Typed>::TYPE.check(&value)?;535		match value {536			Val::Func(a) => Ok(a),537			_ => unreachable!(),538		}539	}540}541impl TryFrom<FuncVal> for Val {542	type Error = LocError;543544	fn try_from(value: FuncVal) -> Result<Self> {545		Ok(Self::Func(value))546	}547}548549impl Typed for Cc<FuncDesc> {550	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);551}552impl TryFrom<Val> for Cc<FuncDesc> {553	type Error = LocError;554555	fn try_from(value: Val) -> Result<Self, Self::Error> {556		<Self as Typed>::TYPE.check(&value)?;557		match value {558			Val::Func(FuncVal::Normal(desc)) => Ok(desc),559			Val::Func(_) => throw!(RuntimeError("expected normal function, not builtin".into())),560			_ => unreachable!(),561		}562	}563}564impl TryFrom<Cc<FuncDesc>> for Val {565	type Error = LocError;566567	fn try_from(value: Cc<FuncDesc>) -> Result<Self, Self::Error> {568		Ok(Self::Func(FuncVal::Normal(value)))569	}570}571572impl Typed for ObjValue {573	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);574}575impl TryFrom<Val> for ObjValue {576	type Error = LocError;577578	fn try_from(value: Val) -> Result<Self> {579		<Self as Typed>::TYPE.check(&value)?;580		match value {581			Val::Obj(a) => Ok(a),582			_ => unreachable!(),583		}584	}585}586impl TryFrom<ObjValue> for Val {587	type Error = LocError;588589	fn try_from(value: ObjValue) -> Result<Self> {590		Ok(Self::Obj(value))591	}592}593594impl Typed for bool {595	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);596}597impl TryFrom<Val> for bool {598	type Error = LocError;599600	fn try_from(value: Val) -> Result<Self> {601		<Self as Typed>::TYPE.check(&value)?;602		match value {603			Val::Bool(a) => Ok(a),604			_ => unreachable!(),605		}606	}607}608impl TryFrom<bool> for Val {609	type Error = LocError;610611	fn try_from(value: bool) -> Result<Self> {612		Ok(Self::Bool(value))613	}614}615616impl Typed for IndexableVal {617	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[618		&ComplexValType::Simple(ValType::Arr),619		&ComplexValType::Simple(ValType::Str),620	]);621}622impl TryFrom<Val> for IndexableVal {623	type Error = LocError;624625	fn try_from(value: Val) -> Result<Self> {626		<Self as Typed>::TYPE.check(&value)?;627		value.into_indexable()628	}629}630impl TryFrom<IndexableVal> for Val {631	type Error = LocError;632633	fn try_from(value: IndexableVal) -> Result<Self> {634		match value {635			IndexableVal::Str(s) => Ok(Self::Str(s)),636			IndexableVal::Arr(a) => Ok(Self::Arr(a)),637		}638	}639}640641pub struct Null;642impl Typed for Null {643	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);644}645impl TryFrom<Val> for Null {646	type Error = LocError;647648	fn try_from(value: Val) -> Result<Self> {649		<Self as Typed>::TYPE.check(&value)?;650		Ok(Self)651	}652}653impl TryFrom<Null> for Val {654	type Error = LocError;655656	fn try_from(_: Null) -> Result<Self> {657		Ok(Self::Null)658	}659}