RPM build fix (reverted CI changes which will need to be un-reverted or made conditional) and vendor Rust dependencies to make builds much faster in any CI system.

zeroidc/vendor/tinyvec/src/array.rs

@@ -0,0 +1,48 @@
+/// A trait for types that are an array.
+///
+/// An "array", for our purposes, has the following properties:
+/// * Owns some number of elements.
+/// * The element type can be generic, but must implement [`Default`].
+/// * The capacity is fixed at compile time, based on the implementing type.
+/// * You can get a shared or mutable slice to the elements.
+///
+/// You are generally **not** expected to need to implement this yourself. It is
+/// already implemented for all the major array lengths (`0..=32` and the powers
+/// of 2 up to 4,096), or for all array lengths with the feature `rustc_1_55`.
+///
+/// **Additional lengths can easily be added upon request.**
+///
+/// ## Safety Reminder
+///
+/// Just a reminder: this trait is 100% safe, which means that `unsafe` code
+/// **must not** rely on an instance of this trait being correct.
+pub trait Array {
+  /// The type of the items in the thing.
+  type Item: Default;
+
+  /// The number of slots in the thing.
+  const CAPACITY: usize;
+
+  /// Gives a shared slice over the whole thing.
+  ///
+  /// A correct implementation will return a slice with a length equal to the
+  /// `CAPACITY` value.
+  fn as_slice(&self) -> &[Self::Item];
+
+  /// Gives a unique slice over the whole thing.
+  ///
+  /// A correct implementation will return a slice with a length equal to the
+  /// `CAPACITY` value.
+  fn as_slice_mut(&mut self) -> &mut [Self::Item];
+
+  /// Create a default-initialized instance of ourself, similar to the
+  /// [`Default`] trait, but implemented for the same range of sizes as
+  /// [`Array`].
+  fn default() -> Self;
+}
+
+#[cfg(feature = "rustc_1_55")]
+mod const_generic_impl;
+
+#[cfg(not(feature = "rustc_1_55"))]
+mod generated_impl;

zeroidc/vendor/tinyvec/src/array/const_generic_impl.rs

@@ -0,0 +1,23 @@
+use super::Array;
+
+impl<T: Default, const N: usize> Array for [T; N] {
+  type Item = T;
+  const CAPACITY: usize = N;
+
+  #[inline(always)]
+  #[must_use]
+  fn as_slice(&self) -> &[T] {
+    &*self
+  }
+
+  #[inline(always)]
+  #[must_use]
+  fn as_slice_mut(&mut self) -> &mut [T] {
+    &mut *self
+  }
+
+  #[inline(always)]
+  fn default() -> Self {
+    [(); N].map(|_| Default::default())
+  }
+}

zeroidc/vendor/tinyvec/src/arrayvec_drain.rs

@@ -0,0 +1,93 @@
+use super::*;
+
+use core::{
+  ops::{Bound, RangeBounds},
+  slice,
+};
+
+/// Draining iterator for [`ArrayVec`]
+///
+/// See [`ArrayVec::drain`](ArrayVec::drain)
+pub struct ArrayVecDrain<'a, T: 'a + Default> {
+  iter: slice::IterMut<'a, T>,
+}
+
+impl<'a, T: 'a + Default> ArrayVecDrain<'a, T> {
+  pub(crate) fn new<A, R>(arr: &'a mut ArrayVec<A>, range: R) -> Self
+  where
+    A: Array<Item = T>,
+    R: RangeBounds<usize>,
+  {
+    let start = match range.start_bound() {
+      Bound::Unbounded => 0,
+      Bound::Included(&n) => n,
+      Bound::Excluded(&n) => n.saturating_add(1),
+    };
+    let end = match range.end_bound() {
+      Bound::Unbounded => arr.len(),
+      Bound::Included(&n) => n.saturating_add(1),
+      Bound::Excluded(&n) => n,
+    };
+
+    assert!(
+      start <= end,
+      "ArrayVec::drain> Illegal range, {} to {}",
+      start,
+      end
+    );
+    assert!(
+      end <= arr.len(),
+      "ArrayVec::drain> Range ends at {}, but length is only {}",
+      end,
+      arr.len()
+    );
+
+    let len = end - start;
+    let to_rotate = &mut arr[start..];
+    to_rotate.rotate_left(len);
+
+    let oldlen = arr.len();
+    let newlen = oldlen - len;
+    arr.set_len(newlen);
+    let slice = &mut arr.data.as_slice_mut()[newlen..oldlen];
+    let iter = slice.iter_mut();
+    Self { iter }
+  }
+}
+
+impl<'a, T: 'a + Default> DoubleEndedIterator for ArrayVecDrain<'a, T> {
+  fn next_back(&mut self) -> Option<Self::Item> {
+    self.iter.next_back().map(take)
+  }
+
+  #[cfg(feature = "rustc_1_40")]
+  fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+    self.iter.nth_back(n).map(take)
+  }
+}
+
+impl<'a, T: 'a + Default> Iterator for ArrayVecDrain<'a, T> {
+  type Item = T;
+  fn next(&mut self) -> Option<Self::Item> {
+    self.iter.next().map(take)
+  }
+  fn size_hint(&self) -> (usize, Option<usize>) {
+    self.iter.size_hint()
+  }
+  fn nth(&mut self, n: usize) -> Option<Self::Item> {
+    self.iter.nth(n).map(take)
+  }
+  fn last(self) -> Option<Self::Item> {
+    self.iter.last().map(take)
+  }
+  fn for_each<F>(self, f: F)
+  where
+    F: FnMut(Self::Item),
+  {
+    self.iter.map(take).for_each(f)
+  }
+}
+
+impl<'a, T: 'a + Default> FusedIterator for ArrayVecDrain<'a, T> {}
+impl<'a, T: 'a + Default> ExactSizeIterator for ArrayVecDrain<'a, T> {}
+/* No need to impl Drop! */

zeroidc/vendor/tinyvec/src/lib.rs

@@ -0,0 +1,107 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![forbid(unsafe_code)]
+#![cfg_attr(
+  feature = "nightly_slice_partition_dedup",
+  feature(slice_partition_dedup)
+)]
+#![cfg_attr(docs_rs, feature(doc_cfg))]
+#![warn(clippy::missing_inline_in_public_items)]
+#![warn(clippy::must_use_candidate)]
+#![warn(missing_docs)]
+
+//! `tinyvec` provides 100% safe vec-like data structures.
+//!
+//! ## Provided Types
+//! With no features enabled, this crate provides the [`ArrayVec`] type, which
+//! is an array-backed storage. You can push values into the array and pop them
+//! out of the array and so on. If the array is made to overflow it will panic.
+//!
+//! Similarly, there is also a [`SliceVec`] type available, which is a vec-like
+//! that's backed by a slice you provide. You can add and remove elements, but
+//! if you overflow the slice it will panic.
+//!
+//! With the `alloc` feature enabled, the crate also has a [`TinyVec`] type.
+//! This is an enum type which is either an `Inline(ArrayVec)` or a `Heap(Vec)`.
+//! If a `TinyVec` is `Inline` and would overflow it automatically transitions
+//! itself into being `Heap` mode instead of a panic.
+//!
+//! All of this is done with no `unsafe` code within the crate. Technically the
+//! `Vec` type from the standard library uses `unsafe` internally, but *this
+//! crate* introduces no new `unsafe` code into your project.
+//!
+//! The limitation is that the element type of a vec from this crate must
+//! support the [`Default`] trait. This means that this crate isn't suitable for
+//! all situations, but a very surprising number of types do support `Default`.
+//!
+//! ## Other Features
+//! * `grab_spare_slice` lets you get access to the "inactive" portions of an
+//!   ArrayVec.
+//! * `rustc_1_40` makes the crate assume a minimum rust version of `1.40.0`,
+//!   which allows some better internal optimizations.
+//! * `serde` provides a `Serialize` and `Deserialize` implementation for
+//!   [`TinyVec`] and [`ArrayVec`] types, provided the inner item also has an
+//!   implementation.
+//!
+//! ## API
+//! The general goal of the crate is that, as much as possible, the vecs here
+//! should be a "drop in" replacement for the standard library `Vec` type. We
+//! strive to provide all of the `Vec` methods with the same names and
+//! signatures. The exception is that the element type of some methods will have
+//! a `Default` bound that's not part of the normal `Vec` type.
+//!
+//! The vecs here also have a few additional methods that aren't on the `Vec`
+//! type. In this case, the names tend to be fairly long so that they are
+//! unlikely to clash with any future methods added to `Vec`.
+//!
+//! ## Stability
+//! * The `1.0` series of the crate works with Rustc `1.34.0` or later, though
+//!   you still need to have Rustc `1.36.0` to use the `alloc` feature.
+//! * The `2.0` version of the crate is planned for some time after the
+//!   `min_const_generics` stuff becomes stable. This would greatly raise the
+//!   minimum rust version and also allow us to totally eliminate the need for
+//!   the `Array` trait. The actual usage of the crate is not expected to break
+//!   significantly in this transition.
+
+#[allow(unused_imports)]
+use core::{
+  borrow::{Borrow, BorrowMut},
+  cmp::PartialEq,
+  convert::AsMut,
+  default::Default,
+  fmt::{
+    Binary, Debug, Display, Formatter, LowerExp, LowerHex, Octal, Pointer,
+    UpperExp, UpperHex,
+  },
+  hash::{Hash, Hasher},
+  iter::{Extend, FromIterator, FusedIterator, IntoIterator, Iterator},
+  mem::{needs_drop, replace},
+  ops::{Deref, DerefMut, Index, IndexMut, RangeBounds},
+  slice::SliceIndex,
+};
+
+#[cfg(feature = "alloc")]
+#[doc(hidden)] // re-export for macros
+pub extern crate alloc;
+
+mod array;
+pub use array::*;
+
+mod arrayvec;
+pub use arrayvec::*;
+
+mod arrayvec_drain;
+pub use arrayvec_drain::*;
+
+mod slicevec;
+pub use slicevec::*;
+
+#[cfg(feature = "alloc")]
+mod tinyvec;
+#[cfg(feature = "alloc")]
+pub use crate::tinyvec::*;
+
+// TODO MSRV(1.40.0): Just call the normal `core::mem::take`
+#[inline(always)]
+fn take<T: Default>(from: &mut T) -> T {
+  replace(from, T::default())
+}