use std::cmp;
use std::iter::RandomAccessIterator;
-use std::iter::{Rev, Enumerate, Repeat, Map, Zip};
+use std::iter::{Enumerate, Repeat, Map, Zip};
use std::ops;
use std::slice;
use std::strbuf::StrBuf;
Bits {bitv: self, next_idx: 0, end_idx: self.nbits}
}
- #[inline]
- #[deprecated = "replaced by .iter().rev()"]
- pub fn rev_iter<'a>(&'a self) -> Rev<Bits<'a>> {
- self.iter().rev()
- }
-
/// Returns `true` if all bits are 0
pub fn none(&self) -> bool {
match self.rep {
// Backlinks over DList::prev are raw pointers that form a full chain in
// the reverse direction.
-use std::iter::Rev;
use std::iter;
use std::mem;
use std::ptr;
Items{nelem: self.len(), head: &self.list_head, tail: self.list_tail}
}
- #[inline]
- #[deprecated = "replaced by .iter().rev()"]
- pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
- self.iter().rev()
- }
-
/// Provide a forward iterator with mutable references
#[inline]
pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
}
}
- #[inline]
- #[deprecated = "replaced by .mut_iter().rev()"]
- pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
- self.mut_iter().rev()
- }
-
/// Consume the list into an iterator yielding elements by value
#[inline]
pub fn move_iter(self) -> MoveItems<T> {
MoveItems{list: self}
}
-
- #[inline]
- #[deprecated = "replaced by .move_iter().rev()"]
- pub fn move_rev_iter(self) -> Rev<MoveItems<T>> {
- self.move_iter().rev()
- }
}
impl<T: TotalOrd> DList<T> {
//! collections::deque::Deque`.
use std::cmp;
-use std::iter::{Rev, RandomAccessIterator};
+use std::iter::RandomAccessIterator;
use deque::Deque;
Items{index: 0, rindex: self.nelts, lo: self.lo, elts: self.elts.as_slice()}
}
- #[deprecated = "replaced by .iter().rev()"]
- pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
- self.iter().rev()
- }
-
/// Front-to-back iterator which returns mutable values.
pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
let start_index = raw_index(self.lo, self.elts.len(), 0);
nelts: self.nelts }
}
}
-
- #[deprecated = "replaced by .mut_iter().rev()"]
- pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
- self.mut_iter().rev()
- }
}
/// RingBuf iterator
#![allow(missing_doc)]
-use std::iter::{Enumerate, FilterMap, Rev};
+use std::iter::{Enumerate, FilterMap};
use std::mem::replace;
use std::{vec, slice};
}
}
- #[deprecated = "replaced by .iter().rev()"]
- pub fn rev_iter<'r>(&'r self) -> Rev<Entries<'r, V>> {
- self.iter().rev()
- }
-
- #[deprecated = "replaced by .mut_iter().rev()"]
- pub fn mut_rev_iter<'r>(&'r mut self) -> Rev<MutEntries<'r, V>> {
- self.mut_iter().rev()
- }
-
/// Empties the hash map, moving all values into the specified closure
pub fn move_iter(&mut self)
-> FilterMap<(uint, Option<V>), (uint, V),
iterator!(impl Entries -> (uint, &'a T), get_ref)
double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref)
-#[deprecated = "replaced by Rev<Entries<'a, T>>"]
-pub type RevEntries<'a, T> = Rev<Entries<'a, T>>;
pub struct MutEntries<'a, T> {
front: uint,
iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
-#[deprecated = "replaced by Rev<MutEntries<'a, T>"]
-pub type RevMutEntries<'a, T> = Rev<MutEntries<'a, T>>;
#[cfg(test)]
mod test_map {
fn slice_to(&self, end: uint) -> &'a [T];
/// Returns an iterator over the vector
fn iter(self) -> Items<'a, T>;
- /// Returns a reversed iterator over a vector
- #[deprecated = "replaced by .iter().rev()"]
- fn rev_iter(self) -> Rev<Items<'a, T>>;
/// Returns an iterator over the subslices of the vector which are
/// separated by elements that match `pred`. The matched element
/// is not contained in the subslices.
/// the subslices.
fn splitn(self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<'a, T>;
/// Returns an iterator over the subslices of the vector which are
- /// separated by elements that match `pred`. This starts at the
- /// end of the vector and works backwards. The matched element is
- /// not contained in the subslices.
- #[deprecated = "replaced by .split(pred).rev()"]
- fn rsplit(self, pred: |&T|: 'a -> bool) -> Rev<Splits<'a, T>>;
- /// Returns an iterator over the subslices of the vector which are
/// separated by elements that match `pred` limited to splitting
/// at most `n` times. This starts at the end of the vector and
/// works backwards. The matched element is not contained in the
}
}
- #[inline]
- #[deprecated = "replaced by .iter().rev()"]
- fn rev_iter(self) -> Rev<Items<'a, T>> {
- self.iter().rev()
- }
-
#[inline]
fn split(self, pred: |&T|: 'a -> bool) -> Splits<'a, T> {
Splits {
}
}
- #[inline]
- #[deprecated = "replaced by .split(pred).rev()"]
- fn rsplit(self, pred: |&T|: 'a -> bool) -> Rev<Splits<'a, T>> {
- self.split(pred).rev()
- }
-
#[inline]
fn rsplitn(self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<'a, T> {
SplitsN {
/// Returns a mutable pointer to the last item in the vector.
fn mut_last(self) -> Option<&'a mut T>;
- /// Returns a reversed iterator that allows modifying each value
- #[deprecated = "replaced by .mut_iter().rev()"]
- fn mut_rev_iter(self) -> Rev<MutItems<'a, T>>;
-
/// Returns an iterator over the mutable subslices of the vector
/// which are separated by elements that match `pred`. The
/// matched element is not contained in the subslices.
Some(&mut self[len - 1])
}
- #[inline]
- #[deprecated = "replaced by .mut_iter().rev()"]
- fn mut_rev_iter(self) -> Rev<MutItems<'a, T>> {
- self.mut_iter().rev()
- }
-
#[inline]
fn mut_split(self, pred: |&T|: 'a -> bool) -> MutSplits<'a, T> {
MutSplits { v: self, pred: pred, finished: false }
}
iterator!{struct Items -> *T, &'a T}
-#[deprecated = "replaced by Rev<Items<'a, T>>"]
-pub type RevItems<'a, T> = Rev<Items<'a, T>>;
impl<'a, T> ExactSize<&'a T> for Items<'a, T> {}
impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {}
}
iterator!{struct MutItems -> *mut T, &'a mut T}
-#[deprecated = "replaced by Rev<MutItems<'a, T>>"]
-pub type RevMutItems<'a, T> = Rev<MutItems<'a, T>>;
/// An iterator over the subslices of the vector which are separated
/// by elements that match `pred`.
use container::Container;
use default::Default;
use iter::{Filter, Map, Iterator};
-use iter::{Rev, DoubleEndedIterator, ExactSize};
+use iter::{DoubleEndedIterator, ExactSize};
use iter::range;
use num::Saturating;
use option::{None, Option, Some};
}
}
-#[deprecated = "replaced by Rev<Chars<'a>>"]
-pub type RevChars<'a> = Rev<Chars<'a>>;
-
-#[deprecated = "replaced by Rev<CharOffsets<'a>>"]
-pub type RevCharOffsets<'a> = Rev<CharOffsets<'a>>;
-
/// External iterator for a string's bytes.
/// Use with the `std::iter` module.
pub type Bytes<'a> =
Map<'a, &'a u8, u8, slice::Items<'a, u8>>;
-#[deprecated = "replaced by Rev<Bytes<'a>>"]
-pub type RevBytes<'a> = Rev<Bytes<'a>>;
-
/// An iterator over the substrings of a string, separated by `sep`.
#[deriving(Clone)]
pub struct CharSplits<'a, Sep> {
finished: bool,
}
-#[deprecated = "replaced by Rev<CharSplits<'a, Sep>>"]
-pub type RevCharSplits<'a, Sep> = Rev<CharSplits<'a, Sep>>;
-
/// An iterator over the substrings of a string, separated by `sep`,
/// splitting at most `count` times.
#[deriving(Clone)]
/// ```
fn chars(&self) -> Chars<'a>;
- /// Do not use this - it is deprecated.
- #[deprecated = "replaced by .chars().rev()"]
- fn chars_rev(&self) -> Rev<Chars<'a>>;
-
/// An iterator over the bytes of `self`
fn bytes(&self) -> Bytes<'a>;
- /// Do not use this - it is deprecated.
- #[deprecated = "replaced by .bytes().rev()"]
- fn bytes_rev(&self) -> Rev<Bytes<'a>>;
-
/// An iterator over the characters of `self` and their byte offsets.
fn char_indices(&self) -> CharOffsets<'a>;
- /// Do not use this - it is deprecated.
- #[deprecated = "replaced by .char_indices().rev()"]
- fn char_indices_rev(&self) -> Rev<CharOffsets<'a>>;
-
/// An iterator over substrings of `self`, separated by characters
/// matched by `sep`.
///
/// ```
fn split_terminator<Sep: CharEq>(&self, sep: Sep) -> CharSplits<'a, Sep>;
- /// Do not use this - it is deprecated.
- #[deprecated = "replaced by .split(sep).rev()"]
- fn rsplit<Sep: CharEq>(&self, sep: Sep) -> Rev<CharSplits<'a, Sep>>;
-
/// An iterator over substrings of `self`, separated by characters
/// matched by `sep`, starting from the end of the string.
/// Restricted to splitting at most `count` times.
Chars{string: *self}
}
- #[inline]
- #[deprecated = "replaced by .chars().rev()"]
- fn chars_rev(&self) -> RevChars<'a> {
- self.chars().rev()
- }
-
#[inline]
fn bytes(&self) -> Bytes<'a> {
self.as_bytes().iter().map(|&b| b)
}
- #[inline]
- #[deprecated = "replaced by .bytes().rev()"]
- fn bytes_rev(&self) -> RevBytes<'a> {
- self.bytes().rev()
- }
-
#[inline]
fn char_indices(&self) -> CharOffsets<'a> {
CharOffsets{string: *self, iter: self.chars()}
}
- #[inline]
- #[deprecated = "replaced by .char_indices().rev()"]
- fn char_indices_rev(&self) -> RevCharOffsets<'a> {
- self.char_indices().rev()
- }
-
#[inline]
fn split<Sep: CharEq>(&self, sep: Sep) -> CharSplits<'a, Sep> {
CharSplits {
}
}
- #[inline]
- #[deprecated = "replaced by .split(sep).rev()"]
- fn rsplit<Sep: CharEq>(&self, sep: Sep) -> RevCharSplits<'a, Sep> {
- self.split(sep).rev()
- }
-
#[inline]
fn rsplitn<Sep: CharEq>(&self, sep: Sep, count: uint)
-> CharSplitsN<'a, Sep> {
}
}
- /// Shuffle a mutable slice in place.
- #[deprecated="renamed to `.shuffle`"]
- fn shuffle_mut<T>(&mut self, values: &mut [T]) {
- self.shuffle(values)
- }
-
/// Randomly sample up to `n` elements from an iterator.
///
/// # Example
fn from_seed(seed: Seed) -> Self;
}
-/// Create a random number generator with a default algorithm and seed.
-///
-/// It returns the strongest `Rng` algorithm currently implemented in
-/// pure Rust. If you require a specifically seeded `Rng` for
-/// consistency over time you should pick one algorithm and create the
-/// `Rng` yourself.
-///
-/// This is a very expensive operation as it has to read randomness
-/// from the operating system and use this in an expensive seeding
-/// operation. If one does not require high performance generation of
-/// random numbers, `task_rng` and/or `random` may be more
-/// appropriate.
-#[deprecated="use `task_rng` or `StdRng::new`"]
-pub fn rng() -> StdRng {
- StdRng::new().unwrap()
-}
-
/// The standard RNG. This is designed to be efficient on the current
/// platform.
#[cfg(not(target_word_size="64"))]
/// Typedef for the platform-native component iterator
#[cfg(unix)]
pub use Components = self::posix::Components;
-/// Typedef for the platform-native reverse component iterator
-#[cfg(unix)]
-pub use RevComponents = self::posix::RevComponents;
/// Typedef for the platform-native component iterator
#[cfg(windows)]
pub use Components = self::windows::Components;
-/// Typedef for the platform-native reverse component iterator
-#[cfg(windows)]
-pub use RevComponents = self::windows::RevComponents;
/// Typedef for the platform-native str component iterator
#[cfg(unix)]
pub use StrComponents = self::posix::StrComponents;
-/// Typedef for the platform-native reverse str component iterator
-#[cfg(unix)]
-pub use RevStrComponents = self::posix::RevStrComponents;
/// Typedef for the platform-native str component iterator
#[cfg(windows)]
pub use StrComponents = self::windows::StrComponents;
-/// Typedef for the platform-native reverse str component iterator
-#[cfg(windows)]
-pub use RevStrComponents = self::windows::RevStrComponents;
/// Alias for the platform-native separator character.
#[cfg(unix)]
use cmp::{Eq, TotalEq};
use from_str::FromStr;
use io::Writer;
-use iter::{DoubleEndedIterator, Rev, AdditiveIterator, Extendable, Iterator, Map};
+use iter::{DoubleEndedIterator, AdditiveIterator, Extendable, Iterator, Map};
use option::{Option, None, Some};
use str;
use str::Str;
/// Iterator that yields successive components of a Path as &[u8]
pub type Components<'a> = Splits<'a, u8>;
-/// Iterator that yields components of a Path in reverse as &[u8]
-#[deprecated = "replaced by Rev<Components<'a>>"]
-pub type RevComponents<'a> = Rev<Components<'a>>;
/// Iterator that yields successive components of a Path as Option<&str>
pub type StrComponents<'a> = Map<'a, &'a [u8], Option<&'a str>,
Components<'a>>;
-/// Iterator that yields components of a Path in reverse as Option<&str>
-#[deprecated = "replaced by Rev<StrComponents<'a>>"]
-pub type RevStrComponents<'a> = Rev<StrComponents<'a>>;
/// Represents a POSIX file path
#[deriving(Clone)]
ret
}
- /// Returns an iterator that yields each component of the path in reverse.
- /// See components() for details.
- #[deprecated = "replaced by .components().rev()"]
- pub fn rev_components<'a>(&'a self) -> Rev<Components<'a>> {
- self.components().rev()
- }
-
/// Returns an iterator that yields each component of the path as Option<&str>.
/// See components() for details.
pub fn str_components<'a>(&'a self) -> StrComponents<'a> {
self.components().map(str::from_utf8)
}
-
- /// Returns an iterator that yields each component of the path in reverse as Option<&str>.
- /// See components() for details.
- #[deprecated = "replaced by .str_components().rev()"]
- pub fn rev_str_components<'a>(&'a self) -> Rev<StrComponents<'a>> {
- self.str_components().rev()
- }
}
// None result means the byte vector didn't need normalizing
use container::Container;
use from_str::FromStr;
use io::Writer;
-use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Rev, Iterator, Map};
+use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Iterator, Map};
use mem;
use option::{Option, Some, None};
use slice::{Vector, OwnedVector, ImmutableVector};
/// every component in WindowsPath is guaranteed to be Some.
pub type StrComponents<'a> = Map<'a, &'a str, Option<&'a str>,
CharSplits<'a, char>>;
-/// Iterator that yields components of a Path in reverse as &str
-///
-/// Each component is yielded as Option<&str> for compatibility with PosixPath, but
-/// every component in WindowsPath is guaranteed to be Some.
-#[deprecated = "replaced by Rev<StrComponents<'a>>"]
-pub type RevStrComponents<'a> = Rev<StrComponents<'a>>;
/// Iterator that yields successive components of a Path as &[u8]
pub type Components<'a> = Map<'a, Option<&'a str>, &'a [u8],
StrComponents<'a>>;
-/// Iterator that yields components of a Path in reverse as &[u8]
-#[deprecated = "replaced by Rev<Components<'a>>"]
-pub type RevComponents<'a> = Rev<Components<'a>>;
/// Represents a Windows path
// Notes for Windows path impl:
ret
}
- /// Returns an iterator that yields each component of the path in reverse as an Option<&str>
- /// See str_components() for details.
- #[deprecated = "replaced by .str_components().rev()"]
- pub fn rev_str_components<'a>(&'a self) -> Rev<StrComponents<'a>> {
- self.str_components().rev()
- }
-
/// Returns an iterator that yields each component of the path in turn as a &[u8].
/// See str_components() for details.
pub fn components<'a>(&'a self) -> Components<'a> {
self.str_components().map(convert)
}
- /// Returns an iterator that yields each component of the path in reverse as a &[u8].
- /// See str_components() for details.
- #[deprecated = "replaced by .components().rev()"]
- pub fn rev_components<'a>(&'a self) -> Rev<Components<'a>> {
- self.components().rev()
- }
-
fn equiv_prefix(&self, other: &Path) -> bool {
let s_repr = self.repr.as_slice();
let o_repr = other.repr.as_slice();
pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
pub use core::slice::{Chunks, Vector, ImmutableVector, ImmutableEqVector};
pub use core::slice::{ImmutableTotalOrdVector, MutableVector, Items, MutItems};
-pub use core::slice::{RevItems, RevMutItems, MutSplits, MutChunks};
+pub use core::slice::{MutSplits, MutChunks};
pub use core::slice::{bytes, MutableCloneableVector};
// Functional utilities
/// }
/// ```
fn move_iter(self) -> MoveItems<T>;
- /// Creates a consuming iterator that moves out of the vector in
- /// reverse order.
- #[deprecated = "replaced by .move_iter().rev()"]
- fn move_rev_iter(self) -> Rev<MoveItems<T>>;
/**
* Partitions the vector into two vectors `(A,B)`, where all
}
}
- #[inline]
- #[deprecated = "replaced by .move_iter().rev()"]
- fn move_rev_iter(self) -> Rev<MoveItems<T>> {
- self.move_iter().rev()
- }
-
#[inline]
fn partition(self, f: |&T| -> bool) -> (Vec<T>, Vec<T>) {
let mut lefts = Vec::new();
}
}
-/// An iterator that moves out of a vector in reverse order.
-#[deprecated = "replaced by Rev<MoveItems<'a, T>>"]
-pub type RevMoveItems<T> = Rev<MoveItems<T>>;
-
#[cfg(test)]
mod tests {
use prelude::*;
use strbuf::StrBuf;
use vec::Vec;
-pub use core::str::{from_utf8, CharEq, Chars, CharOffsets, RevChars};
-pub use core::str::{RevCharOffsets, Bytes, RevBytes, CharSplits, RevCharSplits};
+pub use core::str::{from_utf8, CharEq, Chars, CharOffsets};
+pub use core::str::{Bytes, CharSplits};
pub use core::str::{CharSplitsN, Words, AnyLines, MatchIndices, StrSplits};
pub use core::str::{eq_slice, eq, is_utf8, is_utf16, UTF16Items};
pub use core::str::{UTF16Item, ScalarValue, LoneSurrogate, utf16_items};
projects / rust.git / commitdiff