Always check iterator size when allocating

src/base/allocator.rs

@@ -36,12 +36,27 @@ pub trait Allocator<T, R: Dim, C: Dim = U1>: Any + Sized {
  unsafe fn assume_init(uninit: Self::BufferUninit) -> Self::Buffer;
 
  /// Allocates a buffer initialized with the content of the given iterator.
+ ///
+ /// # Panics
+ ///
+ /// This function will panic if the iterator yields too few or too many
+ /// elements.
  fn allocate_from_iterator<I: IntoIterator<Item = T>>(
  nrows: R,
  ncols: C,
  iter: I,
  ) -> Self::Buffer;
 
+ /// Allocates a buffer from a `Vec<T>`.
+ ///
+ /// # Panics
+ ///
+ /// This function will panic if the `Vec` contains too few or too many
+ /// elements.
+ fn allocate_from_vec(nrows: R, ncols: C, vec: Vec<T>) -> Self::Buffer {
+ Self::allocate_from_iterator(nrows, ncols, vec)
+ }
+
  #[inline]
  /// Allocates a buffer initialized with the content of the given row-major order iterator.
  fn allocate_from_row_iterator<I: IntoIterator<Item = T>>(

src/base/construction.rs

@@ -331,7 +331,7 @@ where
  #[inline]
  #[cfg(any(feature = "std", feature = "alloc"))]
  pub fn from_vec_generic(nrows: R, ncols: C, data: Vec<T>) -> Self {
- Self::from_iterator_generic(nrows, ncols, data)
+ Self::from_data(DefaultAllocator::allocate_from_vec(nrows, ncols, data))
  }
 }
 

src/base/default_allocator.rs

@@ -68,14 +68,16 @@ impl<T: Scalar, const R: usize, const C: usize> Allocator<T, Const<R>, Const<C>>
 
  // Safety: conversion to a slice is OK because the Buffer is known to be contiguous.
  let res_slice = unsafe { res.as_mut_slice_unchecked() };
- for (res, e) in res_slice.iter_mut().zip(iter.into_iter()) {
+ let mut it = iter.into_iter();
+ for (res, e) in res_slice.iter_mut().zip(&mut it) {
  *res = MaybeUninit::new(e);
  count += 1;
  }
 
  assert!(
+ it.next().is_none() &&
  count == nrows.value() * ncols.value(),
- "Matrix init. from iterator: iterator not long enough."
+ "Matrix init. from iterator: the iterator did not yield the correct number of elements."
  );
 
  // Safety: the assertion above made sure that the iterator
@@ -121,13 +123,23 @@ impl<T: Scalar, C: Dim> Allocator<T, Dyn, C> for DefaultAllocator {
  ncols: C,
  iter: I,
  ) -> Self::Buffer {
- let it = iter.into_iter();
- let res: Vec<T> = it.collect();
- assert!(res.len() == nrows.value() * ncols.value(),
- "Allocation from iterator error: the iterator did not yield the correct number of elements.");
+ let size = nrows.value() * ncols.value();
+ let mut it = iter.into_iter();
+ let res: Vec<T> = (&mut it).take(size).collect();
+ assert!(it.next().is_none() && res.len() == size,
+ "Matrix init. from iterator: the iterator did not yield the correct number of elements.");
 
  VecStorage::new(nrows, ncols, res)
  }
+
+ #[inline]
+ fn allocate_from_vec(nrows: Dyn, ncols: C, vec: Vec<T>) -> Self::Buffer {
+ assert!(
+ vec.len() == nrows.value() * ncols.value(),
+ "Matrix init. from vec: the vec does not have the right size."
+ );
+ VecStorage::new(nrows, ncols, vec)
+ }
 }
 
 // Static - Dyn
@@ -167,13 +179,24 @@ impl<T: Scalar, R: DimName> Allocator<T, R, Dyn> for DefaultAllocator {
  ncols: Dyn,
  iter: I,
  ) -> Self::Buffer {
- let it = iter.into_iter();
- let res: Vec<T> = it.collect();
- assert!(res.len() == nrows.value() * ncols.value(),
- "Allocation from iterator error: the iterator did not yield the correct number of elements.");
+ let size = nrows.value() * ncols.value();
+ let mut it = iter.into_iter();
+ let res: Vec<T> = (&mut it).take(size).collect();
+ assert!(it.next().is_none() && res.len() == size,
+ "Matrix init. from iterator: the iterator did not yield the correct number of elements.");
 
  VecStorage::new(nrows, ncols, res)
  }
+
+ #[inline]
+ fn allocate_from_vec(nrows: R, ncols: Dyn, vec: Vec<T>) -> Self::Buffer {
+ assert_eq!(
+ vec.len(),
+ nrows.value() * ncols.value(),
+ "Matrix init. from vec: the vec does not have the right size."
+ );
+ VecStorage::new(nrows, ncols, vec)
+ }
 }
 
 /*
@@ -333,3 +356,119 @@ impl<T: Scalar, RFrom: DimName, RTo: DimName> Reallocator<T, RFrom, Dyn, RTo, Dy
  VecStorage::new(rto, cto, new_buf)
  }
 }
+
+#[cfg(test)]
+mod tests {
+ /// Tests for `DefaultAllocator` with constant dimensions.
+ mod static_static {
+ use crate::{allocator::Allocator, Const, DefaultAllocator};
+
+ #[test]
+ #[should_panic(
+ expected = "Matrix init. from iterator: the iterator did not yield the correct number of elements."
+ )]
+ fn allocate_from_iter_too_small() {
+ let iter = &[1i32];
+ let _ = DefaultAllocator::allocate_from_iterator(Const::<10>, Const::<5>, iter);
+ }
+
+ #[test]
+ #[should_panic(
+ expected = "Matrix init. from iterator: the iterator did not yield the correct number of elements."
+ )]
+ fn allocate_iter_too_big() {
+ let iter = &[1u32, 2, 3, 4, 5, 6, 7];
+ let _ = DefaultAllocator::allocate_from_iterator(Const::<2>, Const::<3>, iter);
+ }
+
+ #[test]
+ #[should_panic(
+ expected = "Matrix init. from iterator: the iterator did not yield the correct number of elements."
+ )]
+ fn allocate_from_vec_too_small() {
+ let vec = vec![1u8];
+ let _ = DefaultAllocator::allocate_from_vec(Const::<4>, Const::<2>, vec);
+ }
+
+ #[test]
+ #[should_panic(
+ expected = "Matrix init. from iterator: the iterator did not yield the correct number of elements."
+ )]
+ fn allocate_from_vec_too_big() {
+ let vec = vec![1usize, 2, 3, 4, 5, 6];
+ let _ = DefaultAllocator::allocate_from_vec(Const::<5>, Const::<1>, vec);
+ }
+ }
+
+ mod dyn_static {
+ use crate::{allocator::Allocator, Const, DefaultAllocator, Dyn};
+
+ #[test]
+ #[should_panic(
+ expected = "Matrix init. from iterator: the iterator did not yield the correct number of elements."
+ )]
+ fn allocate_from_iter_too_small() {
+ let iter = &[1i32];
+ let _ = DefaultAllocator::allocate_from_iterator(Dyn(4), Const::<5>, iter);
+ }
+
+ #[test]
+ #[should_panic(
+ expected = "Matrix init. from iterator: the iterator did not yield the correct number of elements."
+ )]
+ fn allocate_iter_too_big() {
+ let iter = &[1u32, 2, 3, 4];
+ let _ = DefaultAllocator::allocate_from_iterator(Dyn(1), Const::<3>, iter);
+ }
+
+ #[test]
+ #[should_panic(expected = "Matrix init. from vec: the vec does not have the right size.")]
+ fn allocate_from_vec_too_small() {
+ let vec = vec![1u8];
+ let _ = DefaultAllocator::allocate_from_vec(Dyn(4), Const::<2>, vec);
+ }
+
+ #[test]
+ #[should_panic(expected = "Matrix init. from vec: the vec does not have the right size.")]
+ fn allocate_from_vec_too_big() {
+ let vec = vec![1usize, 2, 3, 4, 5, 6];
+ let _ = DefaultAllocator::allocate_from_vec(Dyn(5), Const::<1>, vec);
+ }
+ }
+
+ mod static_dyn {
+ use crate::{allocator::Allocator, Const, DefaultAllocator, Dyn};
+
+ #[test]
+ #[should_panic(
+ expected = "Matrix init. from iterator: the iterator did not yield the correct number of elements."
+ )]
+ fn allocate_from_iter_too_small() {
+ let iter = &[1i32];
+ let _ = DefaultAllocator::allocate_from_iterator(Const::<5>, Dyn(4), iter);
+ }
+
+ #[test]
+ #[should_panic(
+ expected = "Matrix init. from iterator: the iterator did not yield the correct number of elements."
+ )]
+ fn allocate_iter_too_big() {
+ let iter = &[1u32, 2, 3, 4];
+ let _ = DefaultAllocator::allocate_from_iterator(Const::<3>, Dyn(1), iter);
+ }
+
+ #[test]
+ #[should_panic(expected = "Matrix init. from vec: the vec does not have the right size.")]
+ fn allocate_from_vec_too_small() {
+ let vec = vec![1u8];
+ let _ = DefaultAllocator::allocate_from_vec(Const::<2>, Dyn(4), vec);
+ }
+
+ #[test]
+ #[should_panic(expected = "Matrix init. from vec: the vec does not have the right size.")]
+ fn allocate_from_vec_too_big() {
+ let vec = vec![1usize, 2, 3, 4, 5, 6];
+ let _ = DefaultAllocator::allocate_from_vec(Const::<1>, Dyn(5), vec);
+ }
+ }
+}

tests/core/matrix_view.rs

@@ -208,19 +208,19 @@ fn new_from_slice() {
  5.0, 6.0, 7.0, 8.0,
  9.0, 10.0, 11.0, 12.0 ];
 
- let expected2 = Matrix2::from_column_slice(&data);
- let expected3 = Matrix3::from_column_slice(&data);
- let expected2x3 = Matrix2x3::from_column_slice(&data);
- let expected3x2 = Matrix3x2::from_column_slice(&data);
+ let expected2 = Matrix2::from_column_slice(&data[0..4]);
+ let expected3 = Matrix3::from_column_slice(&data[0..9]);
+ let expected2x3 = Matrix2x3::from_column_slice(&data[0..6]);
+ let expected3x2 = Matrix3x2::from_column_slice(&data[0..6]);
 
  {
- let m2 = MatrixView2::from_slice(&data);
- let m3 = MatrixView3::from_slice(&data);
- let m2x3 = MatrixView2x3::from_slice(&data);
- let m3x2 = MatrixView3x2::from_slice(&data);
- let m2xX = MatrixView2xX::from_slice(&data, 3);
- let mXx3 = MatrixViewXx3::from_slice(&data, 2);
- let mXxX = DMatrixView::from_slice(&data, 2, 3);
+ let m2 = MatrixView2::from_slice(&data[0..4]);
+ let m3 = MatrixView3::from_slice(&data[0..9]);
+ let m2x3 = MatrixView2x3::from_slice(&data[0..6]);
+ let m3x2 = MatrixView3x2::from_slice(&data[0..6]);
+ let m2xX = MatrixView2xX::from_slice(&data[0..6], 3);
+ let mXx3 = MatrixViewXx3::from_slice(&data[0..6], 2);
+ let mXxX = DMatrixView::from_slice(&data[0..6], 2, 3);
 
  assert!(m2.eq(&expected2));
  assert!(m3.eq(&expected3));