bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove a slew of old deprecated functions

Browse source
This commit is contained in:
Alex Crichton 2014-05-22 10:40:07 -07:00
parent 257a73ce82
commit 0dd4c1e7bd
12 changed files with 9 additions and 237 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/libcollections/bitv.rs
View file

@ -13,7 +13,7 @@
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;
@ -466,12 +466,6 @@ impl Bitv {
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 {

19
src/libcollections/dlist.rs
View file

@ -21,7 +21,6 @@
// 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;
@ -369,12 +368,6 @@ impl<T> DList<T> {
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> {
@ -390,24 +383,12 @@ impl<T> DList<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> {

12
src/libcollections/ringbuf.rs
View file

@ -14,7 +14,7 @@
//! collections::deque::Deque`.
use std::cmp;
use std::iter::{Rev, RandomAccessIterator};
use std::iter::RandomAccessIterator;
use deque::Deque;
@ -190,11 +190,6 @@ impl<T> RingBuf<T> {
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);
@ -220,11 +215,6 @@ impl<T> RingBuf<T> {
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

16
src/libcollections/smallintmap.rs
View file

@ -15,7 +15,7 @@
#![allow(missing_doc)]
use std::iter::{Enumerate, FilterMap, Rev};
use std::iter::{Enumerate, FilterMap};
use std::mem::replace;
use std::{vec, slice};
@ -142,16 +142,6 @@ impl<V> SmallIntMap<V> {
}
}
#[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),
@ -243,8 +233,6 @@ pub struct Entries<'a, T> {
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,
@ -254,8 +242,6 @@ pub struct MutEntries<'a, T> {
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 {

35
src/libcore/slice.rs
View file

@ -386,9 +386,6 @@ pub trait ImmutableVector<'a, T> {
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.
@ -399,12 +396,6 @@ pub trait ImmutableVector<'a, T> {
/// 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
@ -580,12 +571,6 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
}
}
#[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 {
@ -604,12 +589,6 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
}
}
#[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 {
@ -806,10 +785,6 @@ pub trait MutableVector<'a, T> {
/// 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.
@ -1045,12 +1020,6 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] {
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 }
@ -1354,8 +1323,6 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
}
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> {}
@ -1365,8 +1332,6 @@ impl<'a, T> Clone for Items<'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`.

54
src/libcore/str.rs
View file

@ -20,7 +20,7 @@ use cmp::{Eq, TotalEq};
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};
@ -174,20 +174,11 @@ impl<'a> DoubleEndedIterator<(uint, char)> for CharOffsets<'a> {
}
}
#[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> {
@ -200,9 +191,6 @@ 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)]
@ -1080,24 +1068,12 @@ pub trait StrSlice<'a> {
/// ```
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`.
///
@ -1159,10 +1135,6 @@ pub trait StrSlice<'a> {
/// ```
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.
@ -1681,34 +1653,16 @@ impl<'a> StrSlice<'a> for &'a str {
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 {
@ -1739,12 +1693,6 @@ impl<'a> StrSlice<'a> for &'a str {
}
}
#[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> {

23
src/librand/lib.rs
View file

@ -323,12 +323,6 @@ pub trait Rng {
}
}
/// 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
@ -387,23 +381,6 @@ pub trait SeedableRng<Seed>: Rng {
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"))]

12
src/libstd/path/mod.rs
View file

@ -96,28 +96,16 @@ pub use Path = self::windows::Path;
/// 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)]

22
src/libstd/path/posix.rs
View file

@ -16,7 +16,7 @@ use clone::Clone;
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;
@ -28,16 +28,10 @@ use super::{BytesContainer, GenericPath, GenericPathUnsafe};
/// 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)]
@ -414,25 +408,11 @@ impl Path {
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

25
src/libstd/path/windows.rs
View file

@ -17,7 +17,7 @@ use cmp::{Eq, TotalEq};
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};
@ -33,19 +33,10 @@ use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe};
/// 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:
@ -650,13 +641,6 @@ impl Path {
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> {
@ -667,13 +651,6 @@ impl Path {
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();

16
src/libstd/slice.rs
View file

@ -116,7 +116,7 @@ use vec::Vec;
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
@ -403,10 +403,6 @@ pub trait OwnedVector<T> {
/// }
/// ```
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
@ -425,12 +421,6 @@ impl<T> OwnedVector<T> for ~[T] {
}
}
#[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();
@ -776,10 +766,6 @@ impl<T> Drop for MoveItems<T> {
}
}
/// 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::*;

4
src/libstd/str.rs
View file

@ -93,8 +93,8 @@ use slice::{ImmutableVector, MutableVector, CloneableVector};
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};