vendor/minimal-lexical-0.2.1/src/stackvec.rs - toolchain/rustc - Git at Google

 //! Simple stack-allocated vector.

 #![cfg(not(feature = "alloc"))]
 #![doc(hidden)]

 use crate::bigint;
 use core::{cmp, mem, ops, ptr, slice};

 /// Simple stack vector implementation.
 #[derive(Clone)]
 pub struct StackVec {
     /// The raw buffer for the elements.
     data: [mem::MaybeUninit<bigint::Limb>; bigint::BIGINT_LIMBS],
     /// The number of elements in the array (we never need more than u16::MAX).
     length: u16,
 }

 #[allow(clippy::new_without_default)]
 impl StackVec {
     /// Construct an empty vector.
     #[inline]
     pub const fn new() -> Self {
         Self {
             length: 0,
             data: [mem::MaybeUninit::uninit(); bigint::BIGINT_LIMBS],
         }
     }

     /// Construct a vector from an existing slice.
     #[inline]
     pub fn try_from(x: &[bigint::Limb]) -> Option<Self> {
         let mut vec = Self::new();
         vec.try_extend(x)?;
         Some(vec)
     }

     /// Sets the length of a vector.
     ///
     /// This will explicitly set the size of the vector, without actually
     /// modifying its buffers, so it is up to the caller to ensure that the
     /// vector is actually the specified size.
     ///
     /// # Safety
     ///
     /// Safe as long as `len` is less than `BIGINT_LIMBS`.
     #[inline]
     pub unsafe fn set_len(&mut self, len: usize) {
         // Constant is `u16::MAX` for older Rustc versions.
         debug_assert!(len <= 0xffff);
         debug_assert!(len <= bigint::BIGINT_LIMBS);
         self.length = len as u16;
     }

     /// The number of elements stored in the vector.
     #[inline]
     pub const fn len(&self) -> usize {
         self.length as usize
     }

     /// If the vector is empty.
     #[inline]
     pub const fn is_empty(&self) -> bool {
         self.len() == 0
     }

     /// The number of items the vector can hold.
     #[inline]
     pub const fn capacity(&self) -> usize {
         bigint::BIGINT_LIMBS as usize
     }

     /// Append an item to the vector, without bounds checking.
     ///
     /// # Safety
     ///
     /// Safe if `self.len() < self.capacity()`.
     #[inline]
     pub unsafe fn push_unchecked(&mut self, value: bigint::Limb) {
         debug_assert!(self.len() < self.capacity());
         // SAFETY: safe, capacity is less than the current size.
         unsafe {
             ptr::write(self.as_mut_ptr().add(self.len()), value);
             self.length += 1;
         }
     }

     /// Append an item to the vector.
     #[inline]
     pub fn try_push(&mut self, value: bigint::Limb) -> Option<()> {
         if self.len() < self.capacity() {
             // SAFETY: safe, capacity is less than the current size.
             unsafe { self.push_unchecked(value) };
             Some(())
         } else {
             None
         }
     }

     /// Remove an item from the end of a vector, without bounds checking.
     ///
     /// # Safety
     ///
     /// Safe if `self.len() > 0`.
     #[inline]
     pub unsafe fn pop_unchecked(&mut self) -> bigint::Limb {
         debug_assert!(!self.is_empty());
         // SAFETY: safe if `self.length > 0`.
         // We have a trivial drop and copy, so this is safe.
         self.length -= 1;
         unsafe { ptr::read(self.as_mut_ptr().add(self.len())) }
     }

     /// Remove an item from the end of the vector and return it, or None if empty.
     #[inline]
     pub fn pop(&mut self) -> Option<bigint::Limb> {
         if self.is_empty() {
             None
         } else {
             // SAFETY: safe, since `self.len() > 0`.
             unsafe { Some(self.pop_unchecked()) }
         }
     }

     /// Add items from a slice to the vector, without bounds checking.
     ///
     /// # Safety
     ///
     /// Safe if `self.len() + slc.len() <= self.capacity()`.
     #[inline]
     pub unsafe fn extend_unchecked(&mut self, slc: &[bigint::Limb]) {
         let index = self.len();
         let new_len = index + slc.len();
         debug_assert!(self.len() + slc.len() <= self.capacity());
         let src = slc.as_ptr();
         // SAFETY: safe if `self.len() + slc.len() <= self.capacity()`.
         unsafe {
             let dst = self.as_mut_ptr().add(index);
             ptr::copy_nonoverlapping(src, dst, slc.len());
             self.set_len(new_len);
         }
     }

     /// Copy elements from a slice and append them to the vector.
     #[inline]
     pub fn try_extend(&mut self, slc: &[bigint::Limb]) -> Option<()> {
         if self.len() + slc.len() <= self.capacity() {
             // SAFETY: safe, since `self.len() + slc.len() <= self.capacity()`.
             unsafe { self.extend_unchecked(slc) };
             Some(())
         } else {
             None
         }
     }

     /// Truncate vector to new length, dropping any items after `len`.
     ///
     /// # Safety
     ///
     /// Safe as long as `len <= self.capacity()`.
     unsafe fn truncate_unchecked(&mut self, len: usize) {
         debug_assert!(len <= self.capacity());
         self.length = len as u16;
     }

     /// Resize the buffer, without bounds checking.
     ///
     /// # Safety
     ///
     /// Safe as long as `len <= self.capacity()`.
     #[inline]
     pub unsafe fn resize_unchecked(&mut self, len: usize, value: bigint::Limb) {
         debug_assert!(len <= self.capacity());
         let old_len = self.len();
         if len > old_len {
             // We have a trivial drop, so there's no worry here.
             // Just, don't set the length until all values have been written,
             // so we don't accidentally read uninitialized memory.

             // SAFETY: safe if `len < self.capacity()`.
             let count = len - old_len;
             for index in 0..count {
                 unsafe {
                     let dst = self.as_mut_ptr().add(old_len + index);
                     ptr::write(dst, value);
                 }
             }
             self.length = len as u16;
         } else {
             // SAFETY: safe since `len < self.len()`.
             unsafe { self.truncate_unchecked(len) };
         }
     }

     /// Try to resize the buffer.
     ///
     /// If the new length is smaller than the current length, truncate
     /// the input. If it's larger, then append elements to the buffer.
     #[inline]
     pub fn try_resize(&mut self, len: usize, value: bigint::Limb) -> Option<()> {
         if len > self.capacity() {
             None
         } else {
             // SAFETY: safe, since `len <= self.capacity()`.
             unsafe { self.resize_unchecked(len, value) };
             Some(())
         }
     }

     // HI

     /// Get the high 64 bits from the vector.
     #[inline(always)]
     pub fn hi64(&self) -> (u64, bool) {
         bigint::hi64(self)
     }

     // FROM

     /// Create StackVec from u64 value.
     #[inline(always)]
     pub fn from_u64(x: u64) -> Self {
         bigint::from_u64(x)
     }

     // MATH

     /// Normalize the integer, so any leading zero values are removed.
     #[inline]
     pub fn normalize(&mut self) {
         bigint::normalize(self)
     }

     /// Get if the big integer is normalized.
     #[inline]
     pub fn is_normalized(&self) -> bool {
         bigint::is_normalized(self)
     }

     /// AddAssign small integer.
     #[inline]
     pub fn add_small(&mut self, y: bigint::Limb) -> Option<()> {
         bigint::small_add(self, y)
     }

     /// MulAssign small integer.
     #[inline]
     pub fn mul_small(&mut self, y: bigint::Limb) -> Option<()> {
         bigint::small_mul(self, y)
     }
 }

 impl PartialEq for StackVec {
     #[inline]
     #[allow(clippy::op_ref)]
     fn eq(&self, other: &Self) -> bool {
         use core::ops::Deref;
         self.len() == other.len() && self.deref() == other.deref()
     }
 }

 impl Eq for StackVec {
 }

 impl cmp::PartialOrd for StackVec {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         Some(bigint::compare(self, other))
     }
 }

 impl cmp::Ord for StackVec {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         bigint::compare(self, other)
     }
 }

 impl ops::Deref for StackVec {
     type Target = [bigint::Limb];
     #[inline]
     fn deref(&self) -> &[bigint::Limb] {
         // SAFETY: safe since `self.data[..self.len()]` must be initialized
         // and `self.len() <= self.capacity()`.
         unsafe {
             let ptr = self.data.as_ptr() as *const bigint::Limb;
             slice::from_raw_parts(ptr, self.len())
         }
     }
 }

 impl ops::DerefMut for StackVec {
     #[inline]
     fn deref_mut(&mut self) -> &mut [bigint::Limb] {
         // SAFETY: safe since `self.data[..self.len()]` must be initialized
         // and `self.len() <= self.capacity()`.
         unsafe {
             let ptr = self.data.as_mut_ptr() as *mut bigint::Limb;
             slice::from_raw_parts_mut(ptr, self.len())
         }
     }
 }

 impl ops::MulAssign<&[bigint::Limb]> for StackVec {
     #[inline]
     fn mul_assign(&mut self, rhs: &[bigint::Limb]) {
         bigint::large_mul(self, rhs).unwrap();
     }
 }
	//! Simple stack-allocated vector.

	#![cfg(not(feature = "alloc"))]
	#![doc(hidden)]

	use crate::bigint;
	use core::{cmp, mem, ops, ptr, slice};

	/// Simple stack vector implementation.
	#[derive(Clone)]
	pub struct StackVec {
	/// The raw buffer for the elements.
	data: [mem::MaybeUninit<bigint::Limb>; bigint::BIGINT_LIMBS],
	/// The number of elements in the array (we never need more than u16::MAX).
	length: u16,
	}

	#[allow(clippy::new_without_default)]
	impl StackVec {
	/// Construct an empty vector.
	#[inline]
	pub const fn new() -> Self {
	Self {
	length: 0,
	data: [mem::MaybeUninit::uninit(); bigint::BIGINT_LIMBS],
	}
	}

	/// Construct a vector from an existing slice.
	#[inline]
	pub fn try_from(x: &[bigint::Limb]) -> Option<Self> {
	let mut vec = Self::new();
	vec.try_extend(x)?;
	Some(vec)
	}

	/// Sets the length of a vector.
	///
	/// This will explicitly set the size of the vector, without actually
	/// modifying its buffers, so it is up to the caller to ensure that the
	/// vector is actually the specified size.
	///
	/// # Safety
	///
	/// Safe as long as `len` is less than `BIGINT_LIMBS`.
	#[inline]
	pub unsafe fn set_len(&mut self, len: usize) {
	// Constant is `u16::MAX` for older Rustc versions.
	debug_assert!(len <= 0xffff);
	debug_assert!(len <= bigint::BIGINT_LIMBS);
	self.length = len as u16;
	}

	/// The number of elements stored in the vector.
	#[inline]
	pub const fn len(&self) -> usize {
	self.length as usize
	}

	/// If the vector is empty.
	#[inline]
	pub const fn is_empty(&self) -> bool {
	self.len() == 0
	}

	/// The number of items the vector can hold.
	#[inline]
	pub const fn capacity(&self) -> usize {
	bigint::BIGINT_LIMBS as usize
	}

	/// Append an item to the vector, without bounds checking.
	///
	/// # Safety
	///
	/// Safe if `self.len() < self.capacity()`.
	#[inline]
	pub unsafe fn push_unchecked(&mut self, value: bigint::Limb) {
	debug_assert!(self.len() < self.capacity());
	// SAFETY: safe, capacity is less than the current size.
	unsafe {
	ptr::write(self.as_mut_ptr().add(self.len()), value);
	self.length += 1;
	}
	}

	/// Append an item to the vector.
	#[inline]
	pub fn try_push(&mut self, value: bigint::Limb) -> Option<()> {
	if self.len() < self.capacity() {
	// SAFETY: safe, capacity is less than the current size.
	unsafe { self.push_unchecked(value) };
	Some(())
	} else {
	None
	}
	}

	/// Remove an item from the end of a vector, without bounds checking.
	///
	/// # Safety
	///
	/// Safe if `self.len() > 0`.
	#[inline]
	pub unsafe fn pop_unchecked(&mut self) -> bigint::Limb {
	debug_assert!(!self.is_empty());
	// SAFETY: safe if `self.length > 0`.
	// We have a trivial drop and copy, so this is safe.
	self.length -= 1;
	unsafe { ptr::read(self.as_mut_ptr().add(self.len())) }
	}

	/// Remove an item from the end of the vector and return it, or None if empty.
	#[inline]
	pub fn pop(&mut self) -> Option<bigint::Limb> {
	if self.is_empty() {
	None
	} else {
	// SAFETY: safe, since `self.len() > 0`.
	unsafe { Some(self.pop_unchecked()) }
	}
	}

	/// Add items from a slice to the vector, without bounds checking.
	///
	/// # Safety
	///
	/// Safe if `self.len() + slc.len() <= self.capacity()`.
	#[inline]
	pub unsafe fn extend_unchecked(&mut self, slc: &[bigint::Limb]) {
	let index = self.len();
	let new_len = index + slc.len();
	debug_assert!(self.len() + slc.len() <= self.capacity());
	let src = slc.as_ptr();
	// SAFETY: safe if `self.len() + slc.len() <= self.capacity()`.
	unsafe {
	let dst = self.as_mut_ptr().add(index);
	ptr::copy_nonoverlapping(src, dst, slc.len());
	self.set_len(new_len);
	}
	}

	/// Copy elements from a slice and append them to the vector.
	#[inline]
	pub fn try_extend(&mut self, slc: &[bigint::Limb]) -> Option<()> {
	if self.len() + slc.len() <= self.capacity() {
	// SAFETY: safe, since `self.len() + slc.len() <= self.capacity()`.
	unsafe { self.extend_unchecked(slc) };
	Some(())
	} else {
	None
	}
	}

	/// Truncate vector to new length, dropping any items after `len`.
	///
	/// # Safety
	///
	/// Safe as long as `len <= self.capacity()`.
	unsafe fn truncate_unchecked(&mut self, len: usize) {
	debug_assert!(len <= self.capacity());
	self.length = len as u16;
	}

	/// Resize the buffer, without bounds checking.
	///
	/// # Safety
	///
	/// Safe as long as `len <= self.capacity()`.
	#[inline]
	pub unsafe fn resize_unchecked(&mut self, len: usize, value: bigint::Limb) {
	debug_assert!(len <= self.capacity());
	let old_len = self.len();
	if len > old_len {
	// We have a trivial drop, so there's no worry here.
	// Just, don't set the length until all values have been written,
	// so we don't accidentally read uninitialized memory.

	// SAFETY: safe if `len < self.capacity()`.
	let count = len - old_len;
	for index in 0..count {
	unsafe {
	let dst = self.as_mut_ptr().add(old_len + index);
	ptr::write(dst, value);
	}
	}
	self.length = len as u16;
	} else {
	// SAFETY: safe since `len < self.len()`.
	unsafe { self.truncate_unchecked(len) };
	}
	}

	/// Try to resize the buffer.
	///
	/// If the new length is smaller than the current length, truncate
	/// the input. If it's larger, then append elements to the buffer.
	#[inline]
	pub fn try_resize(&mut self, len: usize, value: bigint::Limb) -> Option<()> {
	if len > self.capacity() {
	None
	} else {
	// SAFETY: safe, since `len <= self.capacity()`.
	unsafe { self.resize_unchecked(len, value) };
	Some(())
	}
	}

	// HI

	/// Get the high 64 bits from the vector.
	#[inline(always)]
	pub fn hi64(&self) -> (u64, bool) {
	bigint::hi64(self)
	}

	// FROM

	/// Create StackVec from u64 value.
	#[inline(always)]
	pub fn from_u64(x: u64) -> Self {
	bigint::from_u64(x)
	}

	// MATH

	/// Normalize the integer, so any leading zero values are removed.
	#[inline]
	pub fn normalize(&mut self) {
	bigint::normalize(self)
	}

	/// Get if the big integer is normalized.
	#[inline]
	pub fn is_normalized(&self) -> bool {
	bigint::is_normalized(self)
	}

	/// AddAssign small integer.
	#[inline]
	pub fn add_small(&mut self, y: bigint::Limb) -> Option<()> {
	bigint::small_add(self, y)
	}

	/// MulAssign small integer.
	#[inline]
	pub fn mul_small(&mut self, y: bigint::Limb) -> Option<()> {
	bigint::small_mul(self, y)
	}
	}

	impl PartialEq for StackVec {
	#[inline]
	#[allow(clippy::op_ref)]
	fn eq(&self, other: &Self) -> bool {
	use core::ops::Deref;
	self.len() == other.len() && self.deref() == other.deref()
	}
	}

	impl Eq for StackVec {
	}

	impl cmp::PartialOrd for StackVec {
	#[inline]
	fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
	Some(bigint::compare(self, other))
	}
	}

	impl cmp::Ord for StackVec {
	#[inline]
	fn cmp(&self, other: &Self) -> cmp::Ordering {
	bigint::compare(self, other)
	}
	}

	impl ops::Deref for StackVec {
	type Target = [bigint::Limb];
	#[inline]
	fn deref(&self) -> &[bigint::Limb] {
	// SAFETY: safe since `self.data[..self.len()]` must be initialized
	// and `self.len() <= self.capacity()`.
	unsafe {
	let ptr = self.data.as_ptr() as *const bigint::Limb;
	slice::from_raw_parts(ptr, self.len())
	}
	}
	}

	impl ops::DerefMut for StackVec {
	#[inline]
	fn deref_mut(&mut self) -> &mut [bigint::Limb] {
	// SAFETY: safe since `self.data[..self.len()]` must be initialized
	// and `self.len() <= self.capacity()`.
	unsafe {
	let ptr = self.data.as_mut_ptr() as *mut bigint::Limb;
	slice::from_raw_parts_mut(ptr, self.len())
	}
	}
	}

	impl ops::MulAssign<&[bigint::Limb]> for StackVec {
	#[inline]
	fn mul_assign(&mut self, rhs: &[bigint::Limb]) {
	bigint::large_mul(self, rhs).unwrap();
	}
	}