core: use assoc types in Iterator et al
This commit is contained in:
parent
fc2ba13939
commit
41df05dd0e
|
@ -446,7 +446,9 @@ enum EscapeUnicodeState {
|
||||||
Done,
|
Done,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Iterator<char> for EscapeUnicode {
|
impl Iterator for EscapeUnicode {
|
||||||
|
type Item = char;
|
||||||
|
|
||||||
fn next(&mut self) -> Option<char> {
|
fn next(&mut self) -> Option<char> {
|
||||||
match self.state {
|
match self.state {
|
||||||
EscapeUnicodeState::Backslash => {
|
EscapeUnicodeState::Backslash => {
|
||||||
|
@ -501,7 +503,9 @@ enum EscapeDefaultState {
|
||||||
Unicode(EscapeUnicode),
|
Unicode(EscapeUnicode),
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Iterator<char> for EscapeDefault {
|
impl Iterator for EscapeDefault {
|
||||||
|
type Item = char;
|
||||||
|
|
||||||
fn next(&mut self) -> Option<char> {
|
fn next(&mut self) -> Option<char> {
|
||||||
match self.state {
|
match self.state {
|
||||||
EscapeDefaultState::Backslash(c) => {
|
EscapeDefaultState::Backslash(c) => {
|
||||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -789,7 +789,9 @@ pub struct Range<Idx> {
|
||||||
|
|
||||||
// FIXME(#19391) needs a snapshot
|
// FIXME(#19391) needs a snapshot
|
||||||
//impl<Idx: Clone + Step<T=uint>> Iterator<Idx> for Range<Idx> {
|
//impl<Idx: Clone + Step<T=uint>> Iterator<Idx> for Range<Idx> {
|
||||||
impl<Idx: Clone + Step> Iterator<Idx> for Range<Idx> {
|
impl<Idx: Clone + Step> Iterator for Range<Idx> {
|
||||||
|
type Item = Idx;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<Idx> {
|
fn next(&mut self) -> Option<Idx> {
|
||||||
if self.start < self.end {
|
if self.start < self.end {
|
||||||
|
@ -811,7 +813,7 @@ impl<Idx: Clone + Step> Iterator<Idx> for Range<Idx> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<Idx: Clone + Step> DoubleEndedIterator<Idx> for Range<Idx> {
|
impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<Idx> {
|
fn next_back(&mut self) -> Option<Idx> {
|
||||||
if self.start < self.end {
|
if self.start < self.end {
|
||||||
|
@ -823,7 +825,7 @@ impl<Idx: Clone + Step> DoubleEndedIterator<Idx> for Range<Idx> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<Idx: Clone + Step> ExactSizeIterator<Idx> for Range<Idx> {}
|
impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
|
||||||
|
|
||||||
/// A range which is only bounded below.
|
/// A range which is only bounded below.
|
||||||
#[deriving(Copy)]
|
#[deriving(Copy)]
|
||||||
|
@ -833,7 +835,9 @@ pub struct RangeFrom<Idx> {
|
||||||
pub start: Idx,
|
pub start: Idx,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<Idx: Clone + Step> Iterator<Idx> for RangeFrom<Idx> {
|
impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
|
||||||
|
type Item = Idx;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<Idx> {
|
fn next(&mut self) -> Option<Idx> {
|
||||||
// Deliberately overflow so we loop forever.
|
// Deliberately overflow so we loop forever.
|
||||||
|
|
|
@ -777,7 +777,9 @@ struct Item<A> {
|
||||||
opt: Option<A>
|
opt: Option<A>
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<A> Iterator<A> for Item<A> {
|
impl<A> Iterator for Item<A> {
|
||||||
|
type Item = A;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<A> {
|
fn next(&mut self) -> Option<A> {
|
||||||
self.opt.take()
|
self.opt.take()
|
||||||
|
@ -792,32 +794,34 @@ impl<A> Iterator<A> for Item<A> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<A> DoubleEndedIterator<A> for Item<A> {
|
impl<A> DoubleEndedIterator for Item<A> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<A> {
|
fn next_back(&mut self) -> Option<A> {
|
||||||
self.opt.take()
|
self.opt.take()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<A> ExactSizeIterator<A> for Item<A> {}
|
impl<A> ExactSizeIterator for Item<A> {}
|
||||||
|
|
||||||
/// An iterator over a reference of the contained item in an Option.
|
/// An iterator over a reference of the contained item in an Option.
|
||||||
#[stable]
|
#[stable]
|
||||||
pub struct Iter<'a, A: 'a> { inner: Item<&'a A> }
|
pub struct Iter<'a, A: 'a> { inner: Item<&'a A> }
|
||||||
|
|
||||||
impl<'a, A> Iterator<&'a A> for Iter<'a, A> {
|
impl<'a, A> Iterator for Iter<'a, A> {
|
||||||
|
type Item = &'a A;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a A> { self.inner.next() }
|
fn next(&mut self) -> Option<&'a A> { self.inner.next() }
|
||||||
#[inline]
|
#[inline]
|
||||||
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, A> DoubleEndedIterator<&'a A> for Iter<'a, A> {
|
impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a A> { self.inner.next_back() }
|
fn next_back(&mut self) -> Option<&'a A> { self.inner.next_back() }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, A> ExactSizeIterator<&'a A> for Iter<'a, A> {}
|
impl<'a, A> ExactSizeIterator for Iter<'a, A> {}
|
||||||
|
|
||||||
#[stable]
|
#[stable]
|
||||||
impl<'a, A> Clone for Iter<'a, A> {
|
impl<'a, A> Clone for Iter<'a, A> {
|
||||||
|
@ -830,37 +834,41 @@ impl<'a, A> Clone for Iter<'a, A> {
|
||||||
#[stable]
|
#[stable]
|
||||||
pub struct IterMut<'a, A: 'a> { inner: Item<&'a mut A> }
|
pub struct IterMut<'a, A: 'a> { inner: Item<&'a mut A> }
|
||||||
|
|
||||||
impl<'a, A> Iterator<&'a mut A> for IterMut<'a, A> {
|
impl<'a, A> Iterator for IterMut<'a, A> {
|
||||||
|
type Item = &'a mut A;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a mut A> { self.inner.next() }
|
fn next(&mut self) -> Option<&'a mut A> { self.inner.next() }
|
||||||
#[inline]
|
#[inline]
|
||||||
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, A> DoubleEndedIterator<&'a mut A> for IterMut<'a, A> {
|
impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() }
|
fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, A> ExactSizeIterator<&'a mut A> for IterMut<'a, A> {}
|
impl<'a, A> ExactSizeIterator for IterMut<'a, A> {}
|
||||||
|
|
||||||
/// An iterator over the item contained inside an Option.
|
/// An iterator over the item contained inside an Option.
|
||||||
#[stable]
|
#[stable]
|
||||||
pub struct IntoIter<A> { inner: Item<A> }
|
pub struct IntoIter<A> { inner: Item<A> }
|
||||||
|
|
||||||
impl<A> Iterator<A> for IntoIter<A> {
|
impl<A> Iterator for IntoIter<A> {
|
||||||
|
type Item = A;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<A> { self.inner.next() }
|
fn next(&mut self) -> Option<A> { self.inner.next() }
|
||||||
#[inline]
|
#[inline]
|
||||||
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<A> DoubleEndedIterator<A> for IntoIter<A> {
|
impl<A> DoubleEndedIterator for IntoIter<A> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<A> { self.inner.next_back() }
|
fn next_back(&mut self) -> Option<A> { self.inner.next_back() }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<A> ExactSizeIterator<A> for IntoIter<A> {}
|
impl<A> ExactSizeIterator for IntoIter<A> {}
|
||||||
|
|
||||||
/////////////////////////////////////////////////////////////////////////////
|
/////////////////////////////////////////////////////////////////////////////
|
||||||
// FromIterator
|
// FromIterator
|
||||||
|
@ -887,7 +895,7 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
#[stable]
|
#[stable]
|
||||||
fn from_iter<I: Iterator<Option<A>>>(iter: I) -> Option<V> {
|
fn from_iter<I: Iterator<Item=Option<A>>>(iter: I) -> Option<V> {
|
||||||
// FIXME(#11084): This could be replaced with Iterator::scan when this
|
// FIXME(#11084): This could be replaced with Iterator::scan when this
|
||||||
// performance bug is closed.
|
// performance bug is closed.
|
||||||
|
|
||||||
|
@ -896,7 +904,9 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
|
||||||
found_none: bool,
|
found_none: bool,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T, Iter: Iterator<Option<T>>> Iterator<T> for Adapter<Iter> {
|
impl<T, Iter: Iterator<Item=Option<T>>> Iterator for Adapter<Iter> {
|
||||||
|
type Item = T;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<T> {
|
fn next(&mut self) -> Option<T> {
|
||||||
match self.iter.next() {
|
match self.iter.next() {
|
||||||
|
|
|
@ -807,7 +807,9 @@ impl<T, E> AsSlice<T> for Result<T, E> {
|
||||||
#[stable]
|
#[stable]
|
||||||
pub struct Iter<'a, T: 'a> { inner: Option<&'a T> }
|
pub struct Iter<'a, T: 'a> { inner: Option<&'a T> }
|
||||||
|
|
||||||
impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
|
impl<'a, T> Iterator for Iter<'a, T> {
|
||||||
|
type Item = &'a T;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a T> { self.inner.take() }
|
fn next(&mut self) -> Option<&'a T> { self.inner.take() }
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -817,12 +819,12 @@ impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T> DoubleEndedIterator<&'a T> for Iter<'a, T> {
|
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a T> { self.inner.take() }
|
fn next_back(&mut self) -> Option<&'a T> { self.inner.take() }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T> ExactSizeIterator<&'a T> for Iter<'a, T> {}
|
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
|
||||||
|
|
||||||
impl<'a, T> Clone for Iter<'a, T> {
|
impl<'a, T> Clone for Iter<'a, T> {
|
||||||
fn clone(&self) -> Iter<'a, T> { Iter { inner: self.inner } }
|
fn clone(&self) -> Iter<'a, T> { Iter { inner: self.inner } }
|
||||||
|
@ -832,7 +834,9 @@ impl<'a, T> Clone for Iter<'a, T> {
|
||||||
#[stable]
|
#[stable]
|
||||||
pub struct IterMut<'a, T: 'a> { inner: Option<&'a mut T> }
|
pub struct IterMut<'a, T: 'a> { inner: Option<&'a mut T> }
|
||||||
|
|
||||||
impl<'a, T> Iterator<&'a mut T> for IterMut<'a, T> {
|
impl<'a, T> Iterator for IterMut<'a, T> {
|
||||||
|
type Item = &'a mut T;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a mut T> { self.inner.take() }
|
fn next(&mut self) -> Option<&'a mut T> { self.inner.take() }
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -842,18 +846,20 @@ impl<'a, T> Iterator<&'a mut T> for IterMut<'a, T> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T> DoubleEndedIterator<&'a mut T> for IterMut<'a, T> {
|
impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a mut T> { self.inner.take() }
|
fn next_back(&mut self) -> Option<&'a mut T> { self.inner.take() }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T> ExactSizeIterator<&'a mut T> for IterMut<'a, T> {}
|
impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
|
||||||
|
|
||||||
/// An iterator over the value in a `Ok` variant of a `Result`.
|
/// An iterator over the value in a `Ok` variant of a `Result`.
|
||||||
#[stable]
|
#[stable]
|
||||||
pub struct IntoIter<T> { inner: Option<T> }
|
pub struct IntoIter<T> { inner: Option<T> }
|
||||||
|
|
||||||
impl<T> Iterator<T> for IntoIter<T> {
|
impl<T> Iterator for IntoIter<T> {
|
||||||
|
type Item = T;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<T> { self.inner.take() }
|
fn next(&mut self) -> Option<T> { self.inner.take() }
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -863,12 +869,12 @@ impl<T> Iterator<T> for IntoIter<T> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T> DoubleEndedIterator<T> for IntoIter<T> {
|
impl<T> DoubleEndedIterator for IntoIter<T> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<T> { self.inner.take() }
|
fn next_back(&mut self) -> Option<T> { self.inner.take() }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T> ExactSizeIterator<T> for IntoIter<T> {}
|
impl<T> ExactSizeIterator for IntoIter<T> {}
|
||||||
|
|
||||||
/////////////////////////////////////////////////////////////////////////////
|
/////////////////////////////////////////////////////////////////////////////
|
||||||
// FromIterator
|
// FromIterator
|
||||||
|
@ -894,7 +900,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
|
||||||
/// assert!(res == Ok(vec!(2u, 3u)));
|
/// assert!(res == Ok(vec!(2u, 3u)));
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
fn from_iter<I: Iterator<Result<A, E>>>(iter: I) -> Result<V, E> {
|
fn from_iter<I: Iterator<Item=Result<A, E>>>(iter: I) -> Result<V, E> {
|
||||||
// FIXME(#11084): This could be replaced with Iterator::scan when this
|
// FIXME(#11084): This could be replaced with Iterator::scan when this
|
||||||
// performance bug is closed.
|
// performance bug is closed.
|
||||||
|
|
||||||
|
@ -903,7 +909,9 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
|
||||||
err: Option<E>,
|
err: Option<E>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T, E, Iter: Iterator<Result<T, E>>> Iterator<T> for Adapter<Iter, E> {
|
impl<T, E, Iter: Iterator<Item=Result<T, E>>> Iterator for Adapter<Iter, E> {
|
||||||
|
type Item = T;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<T> {
|
fn next(&mut self) -> Option<T> {
|
||||||
match self.iter.next() {
|
match self.iter.next() {
|
||||||
|
@ -941,7 +949,7 @@ pub fn fold<T,
|
||||||
V,
|
V,
|
||||||
E,
|
E,
|
||||||
F: FnMut(V, T) -> V,
|
F: FnMut(V, T) -> V,
|
||||||
Iter: Iterator<Result<T, E>>>(
|
Iter: Iterator<Item=Result<T, E>>>(
|
||||||
mut iterator: Iter,
|
mut iterator: Iter,
|
||||||
mut init: V,
|
mut init: V,
|
||||||
mut f: F)
|
mut f: F)
|
||||||
|
|
|
@ -647,7 +647,9 @@ impl<'a, T> Default for &'a [T] {
|
||||||
macro_rules! iterator {
|
macro_rules! iterator {
|
||||||
(struct $name:ident -> $ptr:ty, $elem:ty) => {
|
(struct $name:ident -> $ptr:ty, $elem:ty) => {
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> Iterator<$elem> for $name<'a, T> {
|
impl<'a, T> Iterator for $name<'a, T> {
|
||||||
|
type Item = $elem;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<$elem> {
|
fn next(&mut self) -> Option<$elem> {
|
||||||
// could be implemented with slices, but this avoids bounds checks
|
// could be implemented with slices, but this avoids bounds checks
|
||||||
|
@ -683,7 +685,7 @@ macro_rules! iterator {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> DoubleEndedIterator<$elem> for $name<'a, T> {
|
impl<'a, T> DoubleEndedIterator for $name<'a, T> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<$elem> {
|
fn next_back(&mut self) -> Option<$elem> {
|
||||||
// could be implemented with slices, but this avoids bounds checks
|
// could be implemented with slices, but this avoids bounds checks
|
||||||
|
@ -766,7 +768,7 @@ impl<'a,T> Copy for Iter<'a,T> {}
|
||||||
iterator!{struct Iter -> *const T, &'a T}
|
iterator!{struct Iter -> *const T, &'a T}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> ExactSizeIterator<&'a T> for Iter<'a, T> {}
|
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
|
||||||
|
|
||||||
#[stable]
|
#[stable]
|
||||||
impl<'a, T> Clone for Iter<'a, T> {
|
impl<'a, T> Clone for Iter<'a, T> {
|
||||||
|
@ -774,7 +776,7 @@ impl<'a, T> Clone for Iter<'a, T> {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> RandomAccessIterator<&'a T> for Iter<'a, T> {
|
impl<'a, T> RandomAccessIterator for Iter<'a, T> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn indexable(&self) -> uint {
|
fn indexable(&self) -> uint {
|
||||||
let (exact, _) = self.size_hint();
|
let (exact, _) = self.size_hint();
|
||||||
|
@ -860,14 +862,14 @@ impl<'a, T> IterMut<'a, T> {
|
||||||
iterator!{struct IterMut -> *mut T, &'a mut T}
|
iterator!{struct IterMut -> *mut T, &'a mut T}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> ExactSizeIterator<&'a mut T> for IterMut<'a, T> {}
|
impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
|
||||||
|
|
||||||
/// An internal abstraction over the splitting iterators, so that
|
/// An internal abstraction over the splitting iterators, so that
|
||||||
/// splitn, splitn_mut etc can be implemented once.
|
/// splitn, splitn_mut etc can be implemented once.
|
||||||
trait SplitIter<E>: DoubleEndedIterator<E> {
|
trait SplitIter: DoubleEndedIterator {
|
||||||
/// Mark the underlying iterator as complete, extracting the remaining
|
/// Mark the underlying iterator as complete, extracting the remaining
|
||||||
/// portion of the slice.
|
/// portion of the slice.
|
||||||
fn finish(&mut self) -> Option<E>;
|
fn finish(&mut self) -> Option< <Self as Iterator>::Item>;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// An iterator over subslices separated by elements that match a predicate
|
/// An iterator over subslices separated by elements that match a predicate
|
||||||
|
@ -892,7 +894,9 @@ impl<'a, T, P> Clone for Split<'a, T, P> where P: Clone + FnMut(&T) -> bool {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T, P> Iterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool {
|
impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
|
||||||
|
type Item = &'a [T];
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a [T]> {
|
fn next(&mut self) -> Option<&'a [T]> {
|
||||||
if self.finished { return None; }
|
if self.finished { return None; }
|
||||||
|
@ -918,7 +922,7 @@ impl<'a, T, P> Iterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T, P> DoubleEndedIterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool {
|
impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a [T]> {
|
fn next_back(&mut self) -> Option<&'a [T]> {
|
||||||
if self.finished { return None; }
|
if self.finished { return None; }
|
||||||
|
@ -934,7 +938,7 @@ impl<'a, T, P> DoubleEndedIterator<&'a [T]> for Split<'a, T, P> where P: FnMut(&
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T, P> SplitIter<&'a [T]> for Split<'a, T, P> where P: FnMut(&T) -> bool {
|
impl<'a, T, P> SplitIter for Split<'a, T, P> where P: FnMut(&T) -> bool {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn finish(&mut self) -> Option<&'a [T]> {
|
fn finish(&mut self) -> Option<&'a [T]> {
|
||||||
if self.finished { None } else { self.finished = true; Some(self.v) }
|
if self.finished { None } else { self.finished = true; Some(self.v) }
|
||||||
|
@ -950,7 +954,7 @@ pub struct SplitMut<'a, T:'a, P> where P: FnMut(&T) -> bool {
|
||||||
finished: bool
|
finished: bool
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T, P> SplitIter<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
|
impl<'a, T, P> SplitIter for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn finish(&mut self) -> Option<&'a mut [T]> {
|
fn finish(&mut self) -> Option<&'a mut [T]> {
|
||||||
if self.finished {
|
if self.finished {
|
||||||
|
@ -963,7 +967,9 @@ impl<'a, T, P> SplitIter<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T, P> Iterator<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
|
impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
|
||||||
|
type Item = &'a mut [T];
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a mut [T]> {
|
fn next(&mut self) -> Option<&'a mut [T]> {
|
||||||
if self.finished { return None; }
|
if self.finished { return None; }
|
||||||
|
@ -996,7 +1002,7 @@ impl<'a, T, P> Iterator<&'a mut [T]> for SplitMut<'a, T, P> where P: FnMut(&T) -
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T, P> DoubleEndedIterator<&'a mut [T]> for SplitMut<'a, T, P> where
|
impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P> where
|
||||||
P: FnMut(&T) -> bool,
|
P: FnMut(&T) -> bool,
|
||||||
{
|
{
|
||||||
#[inline]
|
#[inline]
|
||||||
|
@ -1029,9 +1035,11 @@ struct GenericSplitN<I> {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<E, I: SplitIter<E>> Iterator<E> for GenericSplitN<I> {
|
impl<T, I: SplitIter + Iterator<Item=T>> Iterator for GenericSplitN<I> {
|
||||||
|
type Item = T;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<E> {
|
fn next(&mut self) -> Option<T> {
|
||||||
if self.count == 0 {
|
if self.count == 0 {
|
||||||
self.iter.finish()
|
self.iter.finish()
|
||||||
} else {
|
} else {
|
||||||
|
@ -1075,9 +1083,11 @@ pub struct RSplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {
|
||||||
|
|
||||||
macro_rules! forward_iterator {
|
macro_rules! forward_iterator {
|
||||||
($name:ident: $elem:ident, $iter_of:ty) => {
|
($name:ident: $elem:ident, $iter_of:ty) => {
|
||||||
impl<'a, $elem, P> Iterator<$iter_of> for $name<'a, $elem, P> where
|
impl<'a, $elem, P> Iterator for $name<'a, $elem, P> where
|
||||||
P: FnMut(&T) -> bool
|
P: FnMut(&T) -> bool
|
||||||
{
|
{
|
||||||
|
type Item = $iter_of;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<$iter_of> {
|
fn next(&mut self) -> Option<$iter_of> {
|
||||||
self.inner.next()
|
self.inner.next()
|
||||||
|
@ -1104,7 +1114,9 @@ pub struct Windows<'a, T:'a> {
|
||||||
size: uint
|
size: uint
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, T> Iterator<&'a [T]> for Windows<'a, T> {
|
impl<'a, T> Iterator for Windows<'a, T> {
|
||||||
|
type Item = &'a [T];
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a [T]> {
|
fn next(&mut self) -> Option<&'a [T]> {
|
||||||
if self.size > self.v.len() {
|
if self.size > self.v.len() {
|
||||||
|
@ -1140,7 +1152,9 @@ pub struct Chunks<'a, T:'a> {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> Iterator<&'a [T]> for Chunks<'a, T> {
|
impl<'a, T> Iterator for Chunks<'a, T> {
|
||||||
|
type Item = &'a [T];
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a [T]> {
|
fn next(&mut self) -> Option<&'a [T]> {
|
||||||
if self.v.len() == 0 {
|
if self.v.len() == 0 {
|
||||||
|
@ -1167,7 +1181,7 @@ impl<'a, T> Iterator<&'a [T]> for Chunks<'a, T> {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> DoubleEndedIterator<&'a [T]> for Chunks<'a, T> {
|
impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a [T]> {
|
fn next_back(&mut self) -> Option<&'a [T]> {
|
||||||
if self.v.len() == 0 {
|
if self.v.len() == 0 {
|
||||||
|
@ -1183,7 +1197,7 @@ impl<'a, T> DoubleEndedIterator<&'a [T]> for Chunks<'a, T> {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
|
impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn indexable(&self) -> uint {
|
fn indexable(&self) -> uint {
|
||||||
self.v.len()/self.size + if self.v.len() % self.size != 0 { 1 } else { 0 }
|
self.v.len()/self.size + if self.v.len() % self.size != 0 { 1 } else { 0 }
|
||||||
|
@ -1213,7 +1227,9 @@ pub struct ChunksMut<'a, T:'a> {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> Iterator<&'a mut [T]> for ChunksMut<'a, T> {
|
impl<'a, T> Iterator for ChunksMut<'a, T> {
|
||||||
|
type Item = &'a mut [T];
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a mut [T]> {
|
fn next(&mut self) -> Option<&'a mut [T]> {
|
||||||
if self.v.len() == 0 {
|
if self.v.len() == 0 {
|
||||||
|
@ -1241,7 +1257,7 @@ impl<'a, T> Iterator<&'a mut [T]> for ChunksMut<'a, T> {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[experimental = "needs review"]
|
#[experimental = "needs review"]
|
||||||
impl<'a, T> DoubleEndedIterator<&'a mut [T]> for ChunksMut<'a, T> {
|
impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a mut [T]> {
|
fn next_back(&mut self) -> Option<&'a mut [T]> {
|
||||||
if self.v.len() == 0 {
|
if self.v.len() == 0 {
|
||||||
|
|
|
@ -37,7 +37,7 @@ use uint;
|
||||||
macro_rules! delegate_iter {
|
macro_rules! delegate_iter {
|
||||||
(exact $te:ty in $ti:ty) => {
|
(exact $te:ty in $ti:ty) => {
|
||||||
delegate_iter!{$te in $ti}
|
delegate_iter!{$te in $ti}
|
||||||
impl<'a> ExactSizeIterator<$te> for $ti {
|
impl<'a> ExactSizeIterator for $ti {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn rposition<P>(&mut self, predicate: P) -> Option<uint> where P: FnMut($te) -> bool{
|
fn rposition<P>(&mut self, predicate: P) -> Option<uint> where P: FnMut($te) -> bool{
|
||||||
self.0.rposition(predicate)
|
self.0.rposition(predicate)
|
||||||
|
@ -49,7 +49,9 @@ macro_rules! delegate_iter {
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
($te:ty in $ti:ty) => {
|
($te:ty in $ti:ty) => {
|
||||||
impl<'a> Iterator<$te> for $ti {
|
impl<'a> Iterator for $ti {
|
||||||
|
type Item = $te;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<$te> {
|
fn next(&mut self) -> Option<$te> {
|
||||||
self.0.next()
|
self.0.next()
|
||||||
|
@ -59,7 +61,7 @@ macro_rules! delegate_iter {
|
||||||
self.0.size_hint()
|
self.0.size_hint()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl<'a> DoubleEndedIterator<$te> for $ti {
|
impl<'a> DoubleEndedIterator for $ti {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<$te> {
|
fn next_back(&mut self) -> Option<$te> {
|
||||||
self.0.next_back()
|
self.0.next_back()
|
||||||
|
@ -67,7 +69,9 @@ macro_rules! delegate_iter {
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
(pattern $te:ty in $ti:ty) => {
|
(pattern $te:ty in $ti:ty) => {
|
||||||
impl<'a, P: CharEq> Iterator<$te> for $ti {
|
impl<'a, P: CharEq> Iterator for $ti {
|
||||||
|
type Item = $te;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<$te> {
|
fn next(&mut self) -> Option<$te> {
|
||||||
self.0.next()
|
self.0.next()
|
||||||
|
@ -77,7 +81,7 @@ macro_rules! delegate_iter {
|
||||||
self.0.size_hint()
|
self.0.size_hint()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl<'a, P: CharEq> DoubleEndedIterator<$te> for $ti {
|
impl<'a, P: CharEq> DoubleEndedIterator for $ti {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<$te> {
|
fn next_back(&mut self) -> Option<$te> {
|
||||||
self.0.next_back()
|
self.0.next_back()
|
||||||
|
@ -85,7 +89,9 @@ macro_rules! delegate_iter {
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
(pattern forward $te:ty in $ti:ty) => {
|
(pattern forward $te:ty in $ti:ty) => {
|
||||||
impl<'a, P: CharEq> Iterator<$te> for $ti {
|
impl<'a, P: CharEq> Iterator for $ti {
|
||||||
|
type Item = $te;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<$te> {
|
fn next(&mut self) -> Option<$te> {
|
||||||
self.0.next()
|
self.0.next()
|
||||||
|
@ -275,7 +281,9 @@ fn unwrap_or_0(opt: Option<&u8>) -> u8 {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> Iterator<char> for Chars<'a> {
|
impl<'a> Iterator for Chars<'a> {
|
||||||
|
type Item = char;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<char> {
|
fn next(&mut self) -> Option<char> {
|
||||||
// Decode UTF-8, using the valid UTF-8 invariant
|
// Decode UTF-8, using the valid UTF-8 invariant
|
||||||
|
@ -318,7 +326,7 @@ impl<'a> Iterator<char> for Chars<'a> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> DoubleEndedIterator<char> for Chars<'a> {
|
impl<'a> DoubleEndedIterator for Chars<'a> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<char> {
|
fn next_back(&mut self) -> Option<char> {
|
||||||
let w = match self.iter.next_back() {
|
let w = match self.iter.next_back() {
|
||||||
|
@ -359,7 +367,9 @@ pub struct CharIndices<'a> {
|
||||||
iter: Chars<'a>,
|
iter: Chars<'a>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> Iterator<(uint, char)> for CharIndices<'a> {
|
impl<'a> Iterator for CharIndices<'a> {
|
||||||
|
type Item = (uint, char);
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<(uint, char)> {
|
fn next(&mut self) -> Option<(uint, char)> {
|
||||||
let (pre_len, _) = self.iter.iter.size_hint();
|
let (pre_len, _) = self.iter.iter.size_hint();
|
||||||
|
@ -380,7 +390,7 @@ impl<'a> Iterator<(uint, char)> for CharIndices<'a> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> DoubleEndedIterator<(uint, char)> for CharIndices<'a> {
|
impl<'a> DoubleEndedIterator for CharIndices<'a> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<(uint, char)> {
|
fn next_back(&mut self) -> Option<(uint, char)> {
|
||||||
match self.iter.next_back() {
|
match self.iter.next_back() {
|
||||||
|
@ -463,7 +473,9 @@ impl<'a, Sep> CharSplits<'a, Sep> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, Sep: CharEq> Iterator<&'a str> for CharSplits<'a, Sep> {
|
impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
|
||||||
|
type Item = &'a str;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a str> {
|
fn next(&mut self) -> Option<&'a str> {
|
||||||
if self.finished { return None }
|
if self.finished { return None }
|
||||||
|
@ -495,8 +507,7 @@ impl<'a, Sep: CharEq> Iterator<&'a str> for CharSplits<'a, Sep> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, Sep: CharEq> DoubleEndedIterator<&'a str>
|
impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
|
||||||
for CharSplits<'a, Sep> {
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a str> {
|
fn next_back(&mut self) -> Option<&'a str> {
|
||||||
if self.finished { return None }
|
if self.finished { return None }
|
||||||
|
@ -537,7 +548,9 @@ for CharSplits<'a, Sep> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a, Sep: CharEq> Iterator<&'a str> for CharSplitsN<'a, Sep> {
|
impl<'a, Sep: CharEq> Iterator for CharSplitsN<'a, Sep> {
|
||||||
|
type Item = &'a str;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a str> {
|
fn next(&mut self) -> Option<&'a str> {
|
||||||
if self.count != 0 {
|
if self.count != 0 {
|
||||||
|
@ -864,7 +877,9 @@ pub struct SplitStr<'a> {
|
||||||
#[deprecated = "Type is now named `SplitStr`"]
|
#[deprecated = "Type is now named `SplitStr`"]
|
||||||
pub type StrSplits<'a> = SplitStr<'a>;
|
pub type StrSplits<'a> = SplitStr<'a>;
|
||||||
|
|
||||||
impl<'a> Iterator<(uint, uint)> for MatchIndices<'a> {
|
impl<'a> Iterator for MatchIndices<'a> {
|
||||||
|
type Item = (uint, uint);
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<(uint, uint)> {
|
fn next(&mut self) -> Option<(uint, uint)> {
|
||||||
match self.searcher {
|
match self.searcher {
|
||||||
|
@ -878,7 +893,9 @@ impl<'a> Iterator<(uint, uint)> for MatchIndices<'a> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> Iterator<&'a str> for SplitStr<'a> {
|
impl<'a> Iterator for SplitStr<'a> {
|
||||||
|
type Item = &'a str;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a str> {
|
fn next(&mut self) -> Option<&'a str> {
|
||||||
if self.finished { return None; }
|
if self.finished { return None; }
|
||||||
|
@ -1672,23 +1689,27 @@ impl<'a> Default for &'a str {
|
||||||
fn default() -> &'a str { "" }
|
fn default() -> &'a str { "" }
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a> Iterator<&'a str> for Lines<'a> {
|
impl<'a> Iterator for Lines<'a> {
|
||||||
|
type Item = &'a str;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a str> { self.inner.next() }
|
fn next(&mut self) -> Option<&'a str> { self.inner.next() }
|
||||||
#[inline]
|
#[inline]
|
||||||
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
||||||
}
|
}
|
||||||
impl<'a> DoubleEndedIterator<&'a str> for Lines<'a> {
|
impl<'a> DoubleEndedIterator for Lines<'a> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
|
fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
|
||||||
}
|
}
|
||||||
impl<'a> Iterator<&'a str> for LinesAny<'a> {
|
impl<'a> Iterator for LinesAny<'a> {
|
||||||
|
type Item = &'a str;
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next(&mut self) -> Option<&'a str> { self.inner.next() }
|
fn next(&mut self) -> Option<&'a str> { self.inner.next() }
|
||||||
#[inline]
|
#[inline]
|
||||||
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
|
||||||
}
|
}
|
||||||
impl<'a> DoubleEndedIterator<&'a str> for LinesAny<'a> {
|
impl<'a> DoubleEndedIterator for LinesAny<'a> {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
|
fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue