vendor/valuable-0.1.0/src/tuplable.rs - toolchain/rustc - Git at Google

 use crate::{Valuable, Value, Visit};

 use core::fmt;

 /// A tuple-like [`Valuable`] sub-type.
 ///
 /// Implemented by [`Valuable`] types that have a tuple-like shape. Fields are
 /// always unnamed. Values that implement `Tuplable` must return
 /// [`Value::Tuplable`] from their [`Valuable::as_value`] implementation.
 ///
 /// It is uncommon for users to implement this type as the crate provides
 /// implementations of `Tuplable` for Rust tuples.
 ///
 /// # Inspecting
 ///
 /// Inspecting fields contained by a `Tuplable` instance is done by visiting the
 /// tuple. When visiting a `Tuple`, the `visit_unnamed_fields()` method is
 /// called. When the tuple is statically defined, `visit_unnamed_fields()` is
 /// called once with the values of all the fields. A dynamic tuple
 /// implementation may call `visit_unnamed_fields()` multiple times.
 pub trait Tuplable: Valuable {
     /// Returns the tuple's definition.
     ///
     /// See [`TupleDef`] documentation for more details.
     ///
     /// # Examples
     ///
     /// ```
     /// use valuable::{Tuplable, TupleDef};
     ///
     /// let tuple = (123, "hello");
     ///
     /// if let TupleDef::Static { fields, .. } = tuple.definition() {
     ///     assert_eq!(2, fields);
     /// }
     /// ```
     fn definition(&self) -> TupleDef;
 }

 /// The number of fields and other tuple-level information.
 ///
 /// Returned by [`Tuplable::definition()`], `TupleDef` provides the caller with
 /// information about the tuple's definition.
 ///
 /// This includes the number of fields contained by the tuple.
 #[derive(Debug)]
 #[non_exhaustive]
 pub enum TupleDef {
     /// The tuple is statically-defined, all fields are known ahead of time.
     ///
     /// Static tuple implementations are provided by the crate.
     ///
     /// # Examples
     ///
     /// A statically defined tuple.
     ///
     /// ```
     /// use valuable::{Tuplable, TupleDef};
     ///
     /// let tuple = (123, "hello");
     ///
     /// match tuple.definition() {
     ///     TupleDef::Static { fields, .. } => {
     ///         assert_eq!(2, fields);
     ///     }
     ///     _ => unreachable!(),
     /// };
     /// ```
     #[non_exhaustive]
     Static {
         /// The number of fields contained by the tuple.
         fields: usize,
     },
     /// The tuple is dynamically-defined, not all fields are known ahead of
     /// time.
     ///
     /// # Examples
     ///
     /// ```
     /// use valuable::{Tuplable, TupleDef, Valuable, Value, Visit};
     ///
     /// struct MyTuple;
     ///
     /// impl Valuable for MyTuple {
     ///     fn as_value(&self) -> Value<'_> {
     ///         Value::Tuplable(self)
     ///     }
     ///
     ///     fn visit(&self, visit: &mut dyn Visit) {
     ///         visit.visit_unnamed_fields(&[Value::I32(123)]);
     ///         visit.visit_unnamed_fields(&[Value::String("hello world")]);
     ///     }
     /// }
     ///
     /// impl Tuplable for MyTuple {
     ///     fn definition(&self) -> TupleDef {
     ///         TupleDef::new_dynamic((1, Some(3)))
     ///     }
     /// }
     /// ```
     #[non_exhaustive]
     Dynamic {
         /// Returns the bounds on the number of tuple fields.
         ///
         /// Specifically, the first element is the lower bound, and the second
         /// element is the upper bound.
         fields: (usize, Option<usize>),
     },
 }

 macro_rules! deref {
     (
         $(
             $(#[$attrs:meta])*
             $ty:ty,
         )*
     ) => {
         $(
             $(#[$attrs])*
             impl<T: ?Sized + Tuplable> Tuplable for $ty {
                 fn definition(&self) -> TupleDef {
                     T::definition(&**self)
                 }
             }
         )*
     };
 }

 deref! {
     &T,
     &mut T,
     #[cfg(feature = "alloc")]
     alloc::boxed::Box<T>,
     #[cfg(feature = "alloc")]
     alloc::rc::Rc<T>,
     #[cfg(not(valuable_no_atomic_cas))]
     #[cfg(feature = "alloc")]
     alloc::sync::Arc<T>,
 }

 impl Tuplable for () {
     fn definition(&self) -> TupleDef {
         TupleDef::Static { fields: 0 }
     }
 }

 macro_rules! tuple_impls {
     (
         $( $len:expr => ( $($n:tt $name:ident)+ ) )+
     ) => {
         $(
             impl<$($name),+> Valuable for ($($name,)+)
             where
                 $($name: Valuable,)+
             {
                 fn as_value(&self) -> Value<'_> {
                     Value::Tuplable(self)
                 }

                 fn visit(&self, visit: &mut dyn Visit) {
                     visit.visit_unnamed_fields(&[
                         $(
                             self.$n.as_value(),
                         )+
                     ]);
                 }
             }

             impl<$($name),+> Tuplable for ($($name,)+)
             where
                 $($name: Valuable,)+
             {
                 fn definition(&self) -> TupleDef {
                     TupleDef::Static { fields: $len }
                 }
             }
         )+
     }
 }

 tuple_impls! {
     1 => (0 T0)
     2 => (0 T0 1 T1)
     3 => (0 T0 1 T1 2 T2)
     4 => (0 T0 1 T1 2 T2 3 T3)
     5 => (0 T0 1 T1 2 T2 3 T3 4 T4)
     6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
     7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
     8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
     9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
     10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
     11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
     12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
     13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
     14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
     15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
     16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
 }

 impl fmt::Debug for dyn Tuplable + '_ {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.definition().is_unit() {
             ().fmt(fmt)
         } else {
             struct DebugTuple<'a, 'b> {
                 fmt: fmt::DebugTuple<'a, 'b>,
             }

             impl Visit for DebugTuple<'_, '_> {
                 fn visit_unnamed_fields(&mut self, values: &[Value<'_>]) {
                     for value in values {
                         self.fmt.field(value);
                     }
                 }

                 fn visit_value(&mut self, _: Value<'_>) {
                     unimplemented!()
                 }
             }

             let mut debug = DebugTuple {
                 fmt: fmt.debug_tuple(""),
             };

             self.visit(&mut debug);
             debug.fmt.finish()
         }
     }
 }

 impl TupleDef {
     /// Create a new [`TupleDef::Static`] instance
     ///
     /// This should be used when the tuple's fields are fixed and known ahead of time.
     ///
     /// # Examples
     ///
     /// ```
     /// use valuable::TupleDef;
     ///
     /// let def = TupleDef::new_static(2);
     /// ```
     pub const fn new_static(fields: usize) -> TupleDef {
         TupleDef::Static { fields }
     }

     /// Create a new [`TupleDef::Dynamic`] instance.
     ///
     /// This is used when the tuple's fields may vary at runtime.
     ///
     /// # Examples
     ///
     /// ```
     /// use valuable::TupleDef;
     ///
     /// let def = TupleDef::new_dynamic((2, Some(10)));
     /// ```
     pub const fn new_dynamic(fields: (usize, Option<usize>)) -> TupleDef {
         TupleDef::Dynamic { fields }
     }

     /// Returns `true` if `self` represents the [unit][primitive@unit] tuple.
     ///
     /// # Examples
     ///
     /// With the unit tuple
     ///
     /// ```
     /// use valuable::Tuplable;
     ///
     /// let tuple: &dyn Tuplable = &();
     /// assert!(tuple.definition().is_unit());
     /// ```
     ///
     /// When not the unit tuple.
     ///
     /// ```
     /// use valuable::Tuplable;
     ///
     /// let tuple: &dyn Tuplable = &(123,456);
     /// assert!(!tuple.definition().is_unit());
     /// ```
     pub fn is_unit(&self) -> bool {
         match *self {
             TupleDef::Static { fields } => fields == 0,
             TupleDef::Dynamic { fields } => fields == (0, Some(0)),
         }
     }

     /// Returns `true` if the tuple is [statically defined](TupleDef::Static).
     ///
     /// # Examples
     ///
     /// With a static tuple
     ///
     /// ```
     /// use valuable::TupleDef;
     ///
     /// let def = TupleDef::new_static(2);
     /// assert!(def.is_static());
     /// ```
     ///
     /// With a dynamic tuple
     ///
     /// ```
     /// use valuable::TupleDef;
     ///
     /// let def = TupleDef::new_dynamic((2, None));
     /// assert!(!def.is_static());
     /// ```
     pub fn is_static(&self) -> bool {
         matches!(self, TupleDef::Static { .. })
     }

     /// Returns `true` if the tuple is [dynamically defined](TupleDef::Dynamic).
     ///
     /// # Examples
     ///
     /// With a static tuple
     ///
     /// ```
     /// use valuable::TupleDef;
     ///
     /// let def = TupleDef::new_static(2);
     /// assert!(!def.is_dynamic());
     /// ```
     ///
     /// With a dynamic tuple
     ///
     /// ```
     /// use valuable::TupleDef;
     ///
     /// let def = TupleDef::new_dynamic((2, None));
     /// assert!(def.is_dynamic());
     /// ```
     pub fn is_dynamic(&self) -> bool {
         matches!(self, TupleDef::Dynamic { .. })
     }
 }
	use crate::{Valuable, Value, Visit};

	use core::fmt;

	/// A tuple-like [`Valuable`] sub-type.
	///
	/// Implemented by [`Valuable`] types that have a tuple-like shape. Fields are
	/// always unnamed. Values that implement `Tuplable` must return
	/// [`Value::Tuplable`] from their [`Valuable::as_value`] implementation.
	///
	/// It is uncommon for users to implement this type as the crate provides
	/// implementations of `Tuplable` for Rust tuples.
	///
	/// # Inspecting
	///
	/// Inspecting fields contained by a `Tuplable` instance is done by visiting the
	/// tuple. When visiting a `Tuple`, the `visit_unnamed_fields()` method is
	/// called. When the tuple is statically defined, `visit_unnamed_fields()` is
	/// called once with the values of all the fields. A dynamic tuple
	/// implementation may call `visit_unnamed_fields()` multiple times.
	pub trait Tuplable: Valuable {
	/// Returns the tuple's definition.
	///
	/// See [`TupleDef`] documentation for more details.
	///
	/// # Examples
	///
	/// ```
	/// use valuable::{Tuplable, TupleDef};
	///
	/// let tuple = (123, "hello");
	///
	/// if let TupleDef::Static { fields, .. } = tuple.definition() {
	/// assert_eq!(2, fields);
	/// }
	/// ```
	fn definition(&self) -> TupleDef;
	}

	/// The number of fields and other tuple-level information.
	///
	/// Returned by [`Tuplable::definition()`], `TupleDef` provides the caller with
	/// information about the tuple's definition.
	///
	/// This includes the number of fields contained by the tuple.
	#[derive(Debug)]
	#[non_exhaustive]
	pub enum TupleDef {
	/// The tuple is statically-defined, all fields are known ahead of time.
	///
	/// Static tuple implementations are provided by the crate.
	///
	/// # Examples
	///
	/// A statically defined tuple.
	///
	/// ```
	/// use valuable::{Tuplable, TupleDef};
	///
	/// let tuple = (123, "hello");
	///
	/// match tuple.definition() {
	/// TupleDef::Static { fields, .. } => {
	/// assert_eq!(2, fields);
	/// }
	/// _ => unreachable!(),
	/// };
	/// ```
	#[non_exhaustive]
	Static {
	/// The number of fields contained by the tuple.
	fields: usize,
	},
	/// The tuple is dynamically-defined, not all fields are known ahead of
	/// time.
	///
	/// # Examples
	///
	/// ```
	/// use valuable::{Tuplable, TupleDef, Valuable, Value, Visit};
	///
	/// struct MyTuple;
	///
	/// impl Valuable for MyTuple {
	/// fn as_value(&self) -> Value<'_> {
	/// Value::Tuplable(self)
	/// }
	///
	/// fn visit(&self, visit: &mut dyn Visit) {
	/// visit.visit_unnamed_fields(&[Value::I32(123)]);
	/// visit.visit_unnamed_fields(&[Value::String("hello world")]);
	/// }
	/// }
	///
	/// impl Tuplable for MyTuple {
	/// fn definition(&self) -> TupleDef {
	/// TupleDef::new_dynamic((1, Some(3)))
	/// }
	/// }
	/// ```
	#[non_exhaustive]
	Dynamic {
	/// Returns the bounds on the number of tuple fields.
	///
	/// Specifically, the first element is the lower bound, and the second
	/// element is the upper bound.
	fields: (usize, Option<usize>),
	},
	}

	macro_rules! deref {
	(
	$(
	$(#[$attrs:meta])*
	$ty:ty,
	)*
	) => {
	$(
	$(#[$attrs])*
	impl<T: ?Sized + Tuplable> Tuplable for $ty {
	fn definition(&self) -> TupleDef {
	T::definition(&**self)
	}
	}
	)*
	};
	}

	deref! {
	&T,
	&mut T,
	#[cfg(feature = "alloc")]
	alloc::boxed::Box<T>,
	#[cfg(feature = "alloc")]
	alloc::rc::Rc<T>,
	#[cfg(not(valuable_no_atomic_cas))]
	#[cfg(feature = "alloc")]
	alloc::sync::Arc<T>,
	}

	impl Tuplable for () {
	fn definition(&self) -> TupleDef {
	TupleDef::Static { fields: 0 }
	}
	}

	macro_rules! tuple_impls {
	(
	$( $len:expr => ( $($n:tt $name:ident)+ ) )+
	) => {
	$(
	impl<$($name),+> Valuable for ($($name,)+)
	where
	$($name: Valuable,)+
	{
	fn as_value(&self) -> Value<'_> {
	Value::Tuplable(self)
	}

	fn visit(&self, visit: &mut dyn Visit) {
	visit.visit_unnamed_fields(&[
	$(
	self.$n.as_value(),
	)+
	]);
	}
	}

	impl<$($name),+> Tuplable for ($($name,)+)
	where
	$($name: Valuable,)+
	{
	fn definition(&self) -> TupleDef {
	TupleDef::Static { fields: $len }
	}
	}
	)+
	}
	}

	tuple_impls! {
	1 => (0 T0)
	2 => (0 T0 1 T1)
	3 => (0 T0 1 T1 2 T2)
	4 => (0 T0 1 T1 2 T2 3 T3)
	5 => (0 T0 1 T1 2 T2 3 T3 4 T4)
	6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
	7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
	8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
	9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
	10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
	11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
	12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
	13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
	14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
	15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
	16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
	}

	impl fmt::Debug for dyn Tuplable + '_ {
	fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
	if self.definition().is_unit() {
	().fmt(fmt)
	} else {
	struct DebugTuple<'a, 'b> {
	fmt: fmt::DebugTuple<'a, 'b>,
	}

	impl Visit for DebugTuple<'_, '_> {
	fn visit_unnamed_fields(&mut self, values: &[Value<'_>]) {
	for value in values {
	self.fmt.field(value);
	}
	}

	fn visit_value(&mut self, _: Value<'_>) {
	unimplemented!()
	}
	}

	let mut debug = DebugTuple {
	fmt: fmt.debug_tuple(""),
	};

	self.visit(&mut debug);
	debug.fmt.finish()
	}
	}
	}

	impl TupleDef {
	/// Create a new [`TupleDef::Static`] instance
	///
	/// This should be used when the tuple's fields are fixed and known ahead of time.
	///
	/// # Examples
	///
	/// ```
	/// use valuable::TupleDef;
	///
	/// let def = TupleDef::new_static(2);
	/// ```
	pub const fn new_static(fields: usize) -> TupleDef {
	TupleDef::Static { fields }
	}

	/// Create a new [`TupleDef::Dynamic`] instance.
	///
	/// This is used when the tuple's fields may vary at runtime.
	///
	/// # Examples
	///
	/// ```
	/// use valuable::TupleDef;
	///
	/// let def = TupleDef::new_dynamic((2, Some(10)));
	/// ```
	pub const fn new_dynamic(fields: (usize, Option<usize>)) -> TupleDef {
	TupleDef::Dynamic { fields }
	}

	/// Returns `true` if `self` represents the [unit][primitive@unit] tuple.
	///
	/// # Examples
	///
	/// With the unit tuple
	///
	/// ```
	/// use valuable::Tuplable;
	///
	/// let tuple: &dyn Tuplable = &();
	/// assert!(tuple.definition().is_unit());
	/// ```
	///
	/// When not the unit tuple.
	///
	/// ```
	/// use valuable::Tuplable;
	///
	/// let tuple: &dyn Tuplable = &(123,456);
	/// assert!(!tuple.definition().is_unit());
	/// ```
	pub fn is_unit(&self) -> bool {
	match *self {
	TupleDef::Static { fields } => fields == 0,
	TupleDef::Dynamic { fields } => fields == (0, Some(0)),
	}
	}

	/// Returns `true` if the tuple is [statically defined](TupleDef::Static).
	///
	/// # Examples
	///
	/// With a static tuple
	///
	/// ```
	/// use valuable::TupleDef;
	///
	/// let def = TupleDef::new_static(2);
	/// assert!(def.is_static());
	/// ```
	///
	/// With a dynamic tuple
	///
	/// ```
	/// use valuable::TupleDef;
	///
	/// let def = TupleDef::new_dynamic((2, None));
	/// assert!(!def.is_static());
	/// ```
	pub fn is_static(&self) -> bool {
	matches!(self, TupleDef::Static { .. })
	}

	/// Returns `true` if the tuple is [dynamically defined](TupleDef::Dynamic).
	///
	/// # Examples
	///
	/// With a static tuple
	///
	/// ```
	/// use valuable::TupleDef;
	///
	/// let def = TupleDef::new_static(2);
	/// assert!(!def.is_dynamic());
	/// ```
	///
	/// With a dynamic tuple
	///
	/// ```
	/// use valuable::TupleDef;
	///
	/// let def = TupleDef::new_dynamic((2, None));
	/// assert!(def.is_dynamic());
	/// ```
	pub fn is_dynamic(&self) -> bool {
	matches!(self, TupleDef::Dynamic { .. })
	}
	}