core_slice::SliceExt::windows(self, size)
}
- /// Returns an iterator over `size` elements of the slice at a
- /// time. The chunks are slices and do not overlap. If `size` does
+ /// Returns an iterator over `chunk_size` elements of the slice at a
+ /// time. The chunks are slices and do not overlap. If `chunk_size` does
/// not divide the length of the slice, then the last chunk will
- /// not have length `size`.
+ /// not have length `chunk_size`.
///
/// # Panics
///
- /// Panics if `size` is 0.
+ /// Panics if `chunk_size` is 0.
///
/// # Examples
///
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn chunks(&self, size: usize) -> Chunks<T> {
- core_slice::SliceExt::chunks(self, size)
+ pub fn chunks(&self, chunk_size: usize) -> Chunks<T> {
+ core_slice::SliceExt::chunks(self, chunk_size)
}
/// Returns an iterator over `chunk_size` elements of the slice at a time.
}
#[inline]
- fn chunks(&self, size: usize) -> Chunks<T> {
- assert!(size != 0);
- Chunks { v: self, size: size }
+ fn chunks(&self, chunk_size: usize) -> Chunks<T> {
+ assert!(chunk_size != 0);
+ Chunks { v: self, chunk_size: chunk_size }
}
#[inline]
#[unstable(feature = "fused", issue = "35602")]
impl<'a, T> FusedIterator for Windows<'a, T> {}
-/// An iterator over a slice in (non-overlapping) chunks (`size` elements at a
+/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a
/// time).
///
/// When the slice len is not evenly divided by the chunk size, the last slice
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Chunks<'a, T:'a> {
v: &'a [T],
- size: usize
+ chunk_size: usize
}
// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
fn clone(&self) -> Chunks<'a, T> {
Chunks {
v: self.v,
- size: self.size,
+ chunk_size: self.chunk_size,
}
}
}
if self.v.is_empty() {
None
} else {
- let chunksz = cmp::min(self.v.len(), self.size);
+ let chunksz = cmp::min(self.v.len(), self.chunk_size);
let (fst, snd) = self.v.split_at(chunksz);
self.v = snd;
Some(fst)
if self.v.is_empty() {
(0, Some(0))
} else {
- let n = self.v.len() / self.size;
- let rem = self.v.len() % self.size;
+ let n = self.v.len() / self.chunk_size;
+ let rem = self.v.len() % self.chunk_size;
let n = if rem > 0 { n+1 } else { n };
(n, Some(n))
}
#[inline]
fn nth(&mut self, n: usize) -> Option<Self::Item> {
- let (start, overflow) = n.overflowing_mul(self.size);
+ let (start, overflow) = n.overflowing_mul(self.chunk_size);
if start >= self.v.len() || overflow {
self.v = &[];
None
} else {
- let end = match start.checked_add(self.size) {
+ let end = match start.checked_add(self.chunk_size) {
Some(sum) => cmp::min(self.v.len(), sum),
None => self.v.len(),
};
if self.v.is_empty() {
None
} else {
- let start = (self.v.len() - 1) / self.size * self.size;
+ let start = (self.v.len() - 1) / self.chunk_size * self.chunk_size;
Some(&self.v[start..])
}
}
if self.v.is_empty() {
None
} else {
- let remainder = self.v.len() % self.size;
- let chunksz = if remainder != 0 { remainder } else { self.size };
+ let remainder = self.v.len() % self.chunk_size;
+ let chunksz = if remainder != 0 { remainder } else { self.chunk_size };
let (fst, snd) = self.v.split_at(self.v.len() - chunksz);
self.v = fst;
Some(snd)
#[unstable(feature = "fused", issue = "35602")]
impl<'a, T> FusedIterator for Chunks<'a, T> {}
-/// An iterator over a slice in (non-overlapping) mutable chunks (`size`
+/// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`
/// elements at a time). When the slice len is not evenly divided by the chunk
/// size, the last slice of the iteration will be the remainder.
///