2017 day 12

Author: ictrobot

crates/utils/src/array.rs

@@ -0,0 +1,214 @@
+//! Array helpers.
+
+use std::fmt;
+use std::hash::Hash;
+use std::ops::{Deref, DerefMut};
+
+/// A fixed-size array-backed vector.
+///
+/// `ArrayVec` has a fixed-sized `N` long array and a length field to track how many elements are
+/// populated. It is useful for storing a small but variable number of elements without heap
+/// allocation.
+///
+/// The implementation is intentionally simple, and requires [`Copy`] and [`Default`] bounds on some
+/// methods instead of using [`std::mem::MaybeUninit`].
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct ArrayVec<T, const N: usize> {
+    len: usize,
+    data: [T; N],
+}
+
+impl<T, const N: usize> ArrayVec<T, N> {
+    /// Creates a new empty `ArrayVec`.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::array::ArrayVec;
+    /// let vec: ArrayVec<i32, 5> = ArrayVec::new();
+    /// assert_eq!(vec.len(), 0);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn new() -> Self
+    where
+        T: Copy + Default,
+    {
+        Self {
+            len: 0,
+            data: [T::default(); N],
+        }
+    }
+
+    /// Adds an element to the end of the vector.
+    ///
+    /// Returns [`Err`] containing the provided value if the vector is already full.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::array::ArrayVec;
+    /// let mut vec: ArrayVec<i32, 2> = ArrayVec::new();
+    /// assert_eq!(vec.push(1), Ok(()));
+    /// assert_eq!(vec.push(2), Ok(()));
+    /// assert_eq!(vec.push(3), Err(3)); // Vector is full
+    /// ```
+    #[inline]
+    pub fn push(&mut self, value: T) -> Result<(), T> {
+        if self.len < N {
+            self.data[self.len] = value;
+            self.len += 1;
+            Ok(())
+        } else {
+            Err(value)
+        }
+    }
+
+    /// Removes the last element from the vector and returns it, or [`None`] if it is empty.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::array::ArrayVec;
+    /// let mut vec: ArrayVec<i32, 3> = ArrayVec::new();
+    /// vec.push(1).unwrap();
+    /// assert_eq!(vec.pop(), Some(1));
+    /// assert_eq!(vec.pop(), None);
+    /// ```
+    #[inline]
+    pub fn pop(&mut self) -> Option<T>
+    where
+        T: Default,
+    {
+        if self.len > 0 {
+            self.len -= 1;
+            Some(std::mem::take(&mut self.data[self.len]))
+        } else {
+            None
+        }
+    }
+
+    /// Returns a slice of all the populated elements in the vector.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use utils::array::ArrayVec;
+    /// let mut vec: ArrayVec<i32, 3> = ArrayVec::new();
+    /// vec.push(1).unwrap();
+    /// vec.push(2).unwrap();
+    /// assert_eq!(vec.as_slice(), &[1, 2]);
+    /// ```
+    #[inline]
+    pub fn as_slice(&self) -> &[T] {
+        #[cfg(feature = "unsafe")]
+        unsafe {
+            std::hint::assert_unchecked(self.len <= N);
+        }
+
+        &self.data[..self.len]
+    }
+
+    /// Returns a mutable slice of all the populated elements in the vector.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use utils::array::ArrayVec;
+    /// let mut vec: ArrayVec<i32, 3> = ArrayVec::new();
+    /// vec.push(1).unwrap();
+    /// vec.push(2).unwrap();
+    /// let mut slice = vec.as_mut_slice();
+    /// slice[1] = 10;
+    /// assert_eq!(slice, &[1, 10]);
+    /// ```
+    #[inline]
+    pub fn as_mut_slice(&mut self) -> &mut [T] {
+        #[cfg(feature = "unsafe")]
+        unsafe {
+            std::hint::assert_unchecked(self.len <= N);
+        }
+
+        &mut self.data[..self.len]
+    }
+
+    /// Returns the capacity of the vector, which is always `N`.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::array::ArrayVec;
+    /// let vec: ArrayVec<i32, 5> = ArrayVec::new();
+    /// assert_eq!(vec.capacity(), 5);
+    /// ```
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        N
+    }
+
+    /// Returns whether the vector is full.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use utils::array::ArrayVec;
+    /// let mut vec: ArrayVec<i32, 2> = ArrayVec::new();
+    /// assert!(!vec.is_full());
+    /// vec.push(1).unwrap();
+    /// assert!(!vec.is_full());
+    /// vec.push(2).unwrap();
+    /// assert!(vec.is_full());
+    /// ```
+    #[inline]
+    pub fn is_full(&self) -> bool {
+        self.len == N
+    }
+}
+
+impl<T, const N: usize> Deref for ArrayVec<T, N> {
+    type Target = [T];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.as_slice()
+    }
+}
+
+impl<T, const N: usize> DerefMut for ArrayVec<T, N> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.as_mut_slice()
+    }
+}
+
+impl<'a, T, const N: usize> IntoIterator for &'a ArrayVec<T, N> {
+    type Item = &'a T;
+    type IntoIter = std::slice::Iter<'a, T>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<'a, T, const N: usize> IntoIterator for &'a mut ArrayVec<T, N> {
+    type Item = &'a mut T;
+    type IntoIter = std::slice::IterMut<'a, T>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter_mut()
+    }
+}
+
+impl<T: fmt::Debug, const N: usize> fmt::Debug for ArrayVec<T, N> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ArrayVec")
+            .field("len", &self.len)
+            .field("cap", &N)
+            .field("data", &self.as_slice())
+            .finish()
+    }
+}
+
+impl<T: Default + Copy, const N: usize> Default for ArrayVec<T, N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/utils/src/lib.rs

@@ -1,6 +1,7 @@
 //! Common utilities used by the [`aoc`](../aoc/) and year crates.
 #![cfg_attr(not(feature = "unsafe"), forbid(unsafe_code))]
 
+pub mod array;
 pub mod bit;
 pub mod date;
 mod framework;

crates/utils/src/parser/base.rs

@@ -1,6 +1,6 @@
 use crate::input::{InputError, MapWithInputExt};
 use crate::parser::combinator::{
-    Map, MapResult, Optional, Or, RepeatN, RepeatVec, WithPrefix, WithSuffix,
+    Map, MapResult, Optional, Or, RepeatArrayVec, RepeatN, RepeatVec, WithPrefix, WithSuffix,
 };
 use crate::parser::error::WithErrorMsg;
 use crate::parser::simple::{Constant, Eol};
@@ -156,8 +156,8 @@ pub trait Parser: Sized {
 
     /// Repeat this parser `N` times, returning an [`array`].
     ///
-    /// See also [`repeat`](Self::repeat) which returns a [`Vec`] instead, for unknown or varying
-    /// number of repeats.
+    /// If the number of items is variable use [`repeat_arrayvec`](Self::repeat_arrayvec) or
+    /// [`repeat`](Self::repeat).
     ///
     /// # Examples
     /// ```
@@ -177,10 +177,41 @@ pub trait Parser: Sized {
         RepeatN { parser: self }
     }
 
+    /// Repeat this parser while it matches, returning a [`ArrayVec`](crate::array::ArrayVec).
+    ///
+    /// This parser can parse up to `N` items. If more items match, it will return an error.
+    ///
+    /// See [`repeat`](Self::repeat) if the upper bound is large or not known, and
+    /// [`repeat_n`](Self::repeat_n) if the number of items is consistent.
+    ///
+    /// # Examples
+    /// ```
+    /// # use utils::parser::{self, Parser};
+    /// let parser = parser::u32()
+    ///     .repeat(",", 3);
+    /// assert_eq!(parser.parse(b"12,34,56,78"), Ok((vec![12, 34, 56, 78], &b""[..])));
+    /// assert!(parser.parse(b"12,34").is_err());
+    /// ```
+    fn repeat_arrayvec<const N: usize, S: Parser>(
+        self,
+        separator: S,
+        min_elements: usize,
+    ) -> RepeatArrayVec<N, Self, S>
+    where
+        for<'a> Self::Output<'a>: Copy + Default,
+    {
+        RepeatArrayVec {
+            parser: self,
+            separator,
+            min_elements,
+        }
+    }
+
     /// Repeat this parser while it matches, returning a [`Vec`].
     ///
-    /// If the number of items is constant and known in advance, prefer [`repeat_n`](Self::repeat_n)
-    /// as it avoids allocating.
+    /// To avoid allocating, prefer [`repeat_n`](Self::repeat_n) if the number of items is
+    /// consistent and known in advance, or [`repeat_arrayvec`](Self::repeat_arrayvec) if the number
+    /// of items is variable but has a known upper bound.
     ///
     /// # Examples
     /// ```
@@ -356,8 +387,10 @@ impl Parser for &'static str {
 
     #[inline]
     fn parse<'i>(&self, input: &'i [u8]) -> ParseResult<'i, Self::Output<'i>> {
-        if let Some(remainder) = input.strip_prefix(self.as_bytes()) {
-            Ok((self, remainder))
+        // This is faster than using strip_prefix for the common case where the string is a short
+        // string literal known at compile time.
+        if input.len() >= self.len() && self.bytes().zip(input).all(|(a, &b)| a == b) {
+            Ok((self, &input[self.len()..]))
         } else {
             Err((ParseError::ExpectedLiteral(self), input))
         }