nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-26 08:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add 'feature' and 'since' to stability attributes

Browse Source
This commit is contained in:
Brian Anderson 2015-01-12 18:40:19 -08:00
parent 90aa581cff
commit 94ca8a3610
186 changed files with 2822 additions and 2561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/liballoc/arc.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
//! Threadsafe reference-counted boxes (the `Arc<T>` type).
//!
@ -110,7 +110,7 @@ use heap::deallocate;
/// }
/// ```
#[unsafe_no_drop_flag]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Arc<T> {
// FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref
@ -126,7 +126,8 @@ unsafe impl<T: Sync + Send> Sync for Arc<T> { }
/// Weak pointers will not keep the data inside of the `Arc` alive, and can be used to break cycles
/// between `Arc` pointers.
#[unsafe_no_drop_flag]
#[unstable = "Weak pointers may not belong in this module."]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module.")]
pub struct Weak<T> {
// FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref
@ -156,7 +157,7 @@ impl<T> Arc<T> {
/// let five = Arc::new(5i);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new(data: T) -> Arc<T> {
// Start the weak pointer count as 1 which is the weak pointer that's
// held by all the strong pointers (kinda), see std/rc.rs for more info
@ -179,7 +180,8 @@ impl<T> Arc<T> {
///
/// let weak_five = five.downgrade();
/// ```
#[unstable = "Weak pointers may not belong in this module."]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module.")]
pub fn downgrade(&self) -> Weak<T> {
// See the clone() impl for why this is relaxed
self.inner().weak.fetch_add(1, Relaxed);
@ -200,15 +202,15 @@ impl<T> Arc<T> {
/// Get the number of weak references to this value.
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn weak_count<T>(this: &Arc<T>) -> uint { this.inner().weak.load(SeqCst) - 1 }
/// Get the number of strong references to this value.
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn strong_count<T>(this: &Arc<T>) -> uint { this.inner().strong.load(SeqCst) }
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Clone for Arc<T> {
/// Makes a clone of the `Arc<T>`.
///
@ -245,7 +247,7 @@ impl<T> BorrowFrom<Arc<T>> for T {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Deref for Arc<T> {
type Target = T;
@ -271,7 +273,7 @@ impl<T: Send + Sync + Clone> Arc<T> {
/// let mut_five = five.make_unique();
/// ```
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn make_unique(&mut self) -> &mut T {
// Note that we hold a strong reference, which also counts as a weak reference, so we only
// clone if there is an additional reference of either kind.
@ -289,7 +291,7 @@ impl<T: Send + Sync + Clone> Arc<T> {
}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Sync + Send> Drop for Arc<T> {
/// Drops the `Arc<T>`.
///
@ -355,7 +357,8 @@ impl<T: Sync + Send> Drop for Arc<T> {
}
}
#[unstable = "Weak pointers may not belong in this module."]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module.")]
impl<T: Sync + Send> Weak<T> {
/// Upgrades a weak reference to a strong reference.
///
@ -393,7 +396,8 @@ impl<T: Sync + Send> Weak<T> {
}
}
#[unstable = "Weak pointers may not belong in this module."]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module.")]
impl<T: Sync + Send> Clone for Weak<T> {
/// Makes a clone of the `Weak<T>`.
///
@ -417,7 +421,7 @@ impl<T: Sync + Send> Clone for Weak<T> {
}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Sync + Send> Drop for Weak<T> {
/// Drops the `Weak<T>`.
///
@ -460,7 +464,7 @@ impl<T: Sync + Send> Drop for Weak<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: PartialEq> PartialEq for Arc<T> {
/// Equality for two `Arc<T>`s.
///
@ -492,7 +496,7 @@ impl<T: PartialEq> PartialEq for Arc<T> {
/// ```
fn ne(&self, other: &Arc<T>) -> bool { *(*self) != *(*other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: PartialOrd> PartialOrd for Arc<T> {
/// Partial comparison for two `Arc<T>`s.
///
@ -571,11 +575,11 @@ impl<T: PartialOrd> PartialOrd for Arc<T> {
/// ```
fn ge(&self, other: &Arc<T>) -> bool { *(*self) >= *(*other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Ord> Ord for Arc<T> {
fn cmp(&self, other: &Arc<T>) -> Ordering { (**self).cmp(&**other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Eq> Eq for Arc<T> {}
impl<T: fmt::Show> fmt::Show for Arc<T> {
@ -584,16 +588,16 @@ impl<T: fmt::Show> fmt::Show for Arc<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: fmt::String> fmt::String for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&**self, f)
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Default + Sync + Send> Default for Arc<T> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> Arc<T> { Arc::new(Default::default()) }
}

42
src/liballoc/boxed.rs
View File

@ -10,7 +10,7 @@
//! A unique pointer type.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use core::any::Any;
use core::clone::Clone;
@ -44,35 +44,36 @@ use core::ops::{Deref, DerefMut};
/// }
/// ```
#[lang = "exchange_heap"]
#[unstable = "may be renamed; uncertain about custom allocator design"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "may be renamed; uncertain about custom allocator design")]
pub static HEAP: () = ();
/// A type that represents a uniquely-owned value.
#[lang = "owned_box"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Box<T>(Unique<T>);
impl<T> Box<T> {
/// Moves `x` into a freshly allocated box on the global exchange heap.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new(x: T) -> Box<T> {
box x
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Default> Default for Box<T> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> Box<T> { box Default::default() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Default for Box<[T]> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> Box<[T]> { box [] }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Clone> Clone for Box<T> {
/// Returns a copy of the owned box.
#[inline]
@ -85,14 +86,14 @@ impl<T: Clone> Clone for Box<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: ?Sized + PartialEq> PartialEq for Box<T> {
#[inline]
fn eq(&self, other: &Box<T>) -> bool { PartialEq::eq(&**self, &**other) }
#[inline]
fn ne(&self, other: &Box<T>) -> bool { PartialEq::ne(&**self, &**other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: ?Sized + PartialOrd> PartialOrd for Box<T> {
#[inline]
fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {
@ -107,14 +108,14 @@ impl<T: ?Sized + PartialOrd> PartialOrd for Box<T> {
#[inline]
fn gt(&self, other: &Box<T>) -> bool { PartialOrd::gt(&**self, &**other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: ?Sized + Ord> Ord for Box<T> {
#[inline]
fn cmp(&self, other: &Box<T>) -> Ordering {
Ord::cmp(&**self, &**other)
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: ?Sized + Eq> Eq for Box<T> {}
impl<S: hash::Hasher, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
@ -125,19 +126,20 @@ impl<S: hash::Hasher, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
}
/// Extension methods for an owning `Any` trait object.
#[unstable = "this trait will likely disappear once compiler bugs blocking \
a direct impl on `Box<Any>` have been fixed "]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this trait will likely disappear once compiler bugs blocking \
a direct impl on `Box<Any>` have been fixed ")]
// FIXME(#18737): this should be a direct impl on `Box<Any>`. If you're
// removing this please make sure that you can downcase on
// `Box<Any + Send>` as well as `Box<Any>`
pub trait BoxAny {
/// Returns the boxed value if it is of type `T`, or
/// `Err(Self)` if it isn't.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn downcast<T: 'static>(self) -> Result<Box<T>, Self>;
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl BoxAny for Box<Any> {
#[inline]
fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any>> {
@ -162,7 +164,7 @@ impl<T: ?Sized + fmt::Show> fmt::Show for Box<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: ?Sized + fmt::String> fmt::String for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&**self, f)
@ -175,14 +177,14 @@ impl fmt::Show for Box<Any> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: ?Sized> Deref for Box<T> {
type Target = T;
fn deref(&self) -> &T { &**self }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: ?Sized> DerefMut for Box<T> {
fn deref_mut(&mut self) -> &mut T { &mut **self }
}

2
src/liballoc/heap.rs
View File

@ -80,7 +80,7 @@ pub fn usable_size(size: uint, align: uint) -> uint {
///
/// These statistics may be inconsistent if other threads use the allocator
/// during the call.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn stats_print() {
imp::stats_print();
}

2
src/liballoc/lib.rs
View File

@ -57,7 +57,7 @@
//! default global allocator. It is not compatible with the libc allocator API.
#![crate_name = "alloc"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "rlib"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",

66
src/liballoc/rc.rs
View File

@ -142,7 +142,7 @@
//! }
//! ```
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use core::borrow::BorrowFrom;
use core::cell::Cell;
@ -173,8 +173,8 @@ struct RcBox<T> {
///
/// See the [module level documentation](../index.html) for more details.
#[unsafe_no_drop_flag]
#[stable]
#[cfg(stage0)] // NOTE remove impl after next snapshot
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Rc<T> {
// FIXME #12808: strange names to try to avoid interfering with field accesses of the contained
// type via Deref
@ -187,7 +187,7 @@ pub struct Rc<T> {
///
/// See the [module level documentation](../index.html) for more details.
#[unsafe_no_drop_flag]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot
pub struct Rc<T> {
// FIXME #12808: strange names to try to avoid interfering with field accesses of the contained
@ -211,8 +211,8 @@ impl<T> Rc<T> {
///
/// let five = Rc::new(5i);
/// ```
#[stable]
#[cfg(stage0)] // NOTE remove after next snapshot
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new(value: T) -> Rc<T> {
unsafe {
Rc {
@ -239,7 +239,7 @@ impl<T> Rc<T> {
///
/// let five = Rc::new(5i);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot
pub fn new(value: T) -> Rc<T> {
unsafe {
@ -268,7 +268,8 @@ impl<T> Rc<T> {
/// let weak_five = five.downgrade();
/// ```
#[cfg(stage0)] // NOTE remove after next snapshot
#[unstable = "Weak pointers may not belong in this module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module")]
pub fn downgrade(&self) -> Weak<T> {
self.inc_weak();
Weak {
@ -290,7 +291,8 @@ impl<T> Rc<T> {
/// let weak_five = five.downgrade();
/// ```
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot
#[unstable = "Weak pointers may not belong in this module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module")]
pub fn downgrade(&self) -> Weak<T> {
self.inc_weak();
Weak { _ptr: self._ptr }
@ -299,12 +301,12 @@ impl<T> Rc<T> {
/// Get the number of weak references to this value.
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn weak_count<T>(this: &Rc<T>) -> uint { this.weak() - 1 }
/// Get the number of strong references to this value.
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() }
/// Returns true if there are no other `Rc` or `Weak<T>` values that share the same inner value.
@ -320,7 +322,7 @@ pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() }
/// rc::is_unique(&five);
/// ```
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn is_unique<T>(rc: &Rc<T>) -> bool {
weak_count(rc) == 0 && strong_count(rc) == 1
}
@ -342,7 +344,7 @@ pub fn is_unique<T>(rc: &Rc<T>) -> bool {
/// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u)));
/// ```
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
if is_unique(&rc) {
unsafe {
@ -376,7 +378,7 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
/// assert!(rc::get_mut(&mut x).is_none());
/// ```
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn get_mut<'a, T>(rc: &'a mut Rc<T>) -> Option<&'a mut T> {
if is_unique(rc) {
let inner = unsafe { &mut **rc._ptr };
@ -402,7 +404,7 @@ impl<T: Clone> Rc<T> {
/// let mut_five = five.make_unique();
/// ```
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn make_unique(&mut self) -> &mut T {
if !is_unique(self) {
*self = Rc::new((**self).clone())
@ -422,7 +424,7 @@ impl<T> BorrowFrom<Rc<T>> for T {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Deref for Rc<T> {
type Target = T;
@ -433,7 +435,7 @@ impl<T> Deref for Rc<T> {
}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Drop for Rc<T> {
/// Drops the `Rc<T>`.
///
@ -481,7 +483,7 @@ impl<T> Drop for Rc<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Clone for Rc<T> {
/// Makes a clone of the `Rc<T>`.
///
@ -524,7 +526,7 @@ impl<T> Clone for Rc<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Default> Default for Rc<T> {
/// Creates a new `Rc<T>`, with the `Default` value for `T`.
///
@ -537,13 +539,13 @@ impl<T: Default> Default for Rc<T> {
/// let x: Rc<int> = Default::default();
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> Rc<T> {
Rc::new(Default::default())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: PartialEq> PartialEq for Rc<T> {
/// Equality for two `Rc<T>`s.
///
@ -578,10 +580,10 @@ impl<T: PartialEq> PartialEq for Rc<T> {
fn ne(&self, other: &Rc<T>) -> bool { **self != **other }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Eq> Eq for Rc<T> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: PartialOrd> PartialOrd for Rc<T> {
/// Partial comparison for two `Rc<T>`s.
///
@ -666,7 +668,7 @@ impl<T: PartialOrd> PartialOrd for Rc<T> {
fn ge(&self, other: &Rc<T>) -> bool { **self >= **other }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Ord> Ord for Rc<T> {
/// Comparison for two `Rc<T>`s.
///
@ -693,14 +695,14 @@ impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> {
}
}
#[unstable = "Show is experimental."]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "Show is experimental.")]
impl<T: fmt::Show> fmt::Show for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Rc({:?})", **self)
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: fmt::String> fmt::String for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&**self, f)
@ -713,8 +715,9 @@ impl<T: fmt::String> fmt::String for Rc<T> {
///
/// See the [module level documentation](../index.html) for more.
#[unsafe_no_drop_flag]
#[unstable = "Weak pointers may not belong in this module."]
#[cfg(stage0)] // NOTE remove impl after next snapshot
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module.")]
pub struct Weak<T> {
// FIXME #12808: strange names to try to avoid interfering with
// field accesses of the contained type via Deref
@ -729,7 +732,8 @@ pub struct Weak<T> {
///
/// See the [module level documentation](../index.html) for more.
#[unsafe_no_drop_flag]
#[unstable = "Weak pointers may not belong in this module."]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module.")]
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot
pub struct Weak<T> {
// FIXME #12808: strange names to try to avoid interfering with
@ -746,7 +750,8 @@ impl<T> !marker::Send for Weak<T> {}
impl<T> !marker::Sync for Weak<T> {}
#[unstable = "Weak pointers may not belong in this module."]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module.")]
impl<T> Weak<T> {
/// Upgrades a weak reference to a strong reference.
///
@ -804,7 +809,7 @@ impl<T> Weak<T> {
}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Drop for Weak<T> {
/// Drops the `Weak<T>`.
///
@ -847,7 +852,8 @@ impl<T> Drop for Weak<T> {
}
}
#[unstable = "Weak pointers may not belong in this module."]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Weak pointers may not belong in this module.")]
impl<T> Clone for Weak<T> {
/// Makes a clone of the `Weak<T>`.
///
@ -890,7 +896,7 @@ impl<T> Clone for Weak<T> {
}
}
#[unstable = "Show is experimental."]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "Show is experimental.")]
impl<T: fmt::Show> fmt::Show for Weak<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "(Weak)")

2
src/libarena/lib.rs
View File

@ -20,7 +20,7 @@
//! more complex, slower arena which can hold objects of any type.
#![crate_name = "arena"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "rlib"]
#![crate_type = "dylib"]

67
src/libcollections/binary_heap.rs
View File

@ -148,7 +148,7 @@
//! ```
#![allow(missing_docs)]
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use core::prelude::*;
@ -164,12 +164,12 @@ use vec::{self, Vec};
///
/// This will be a max-heap.
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct BinaryHeap<T> {
data: Vec<T>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Ord> Default for BinaryHeap<T> {
#[inline]
fn default() -> BinaryHeap<T> { BinaryHeap::new() }
@ -185,7 +185,7 @@ impl<T: Ord> BinaryHeap<T> {
/// let mut heap = BinaryHeap::new();
/// heap.push(4u);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> BinaryHeap<T> { BinaryHeap { data: vec![] } }
/// Creates an empty `BinaryHeap` with a specific capacity.
@ -200,7 +200,7 @@ impl<T: Ord> BinaryHeap<T> {
/// let mut heap = BinaryHeap::with_capacity(10);
/// heap.push(4u);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn with_capacity(capacity: uint) -> BinaryHeap<T> {
BinaryHeap { data: Vec::with_capacity(capacity) }
}
@ -238,7 +238,7 @@ impl<T: Ord> BinaryHeap<T> {
/// println!("{}", x);
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
Iter { iter: self.data.iter() }
}
@ -259,7 +259,7 @@ impl<T: Ord> BinaryHeap<T> {
/// println!("{}", x);
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<T> {
IntoIter { iter: self.data.into_iter() }
}
@ -279,7 +279,7 @@ impl<T: Ord> BinaryHeap<T> {
/// assert_eq!(heap.peek(), Some(&5));
///
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn peek(&self) -> Option<&T> {
self.data.get(0)
}
@ -294,7 +294,7 @@ impl<T: Ord> BinaryHeap<T> {
/// assert!(heap.capacity() >= 100);
/// heap.push(4u);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn capacity(&self) -> uint { self.data.capacity() }
/// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
@ -317,7 +317,7 @@ impl<T: Ord> BinaryHeap<T> {
/// assert!(heap.capacity() >= 100);
/// heap.push(4u);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve_exact(&mut self, additional: uint) {
self.data.reserve_exact(additional);
}
@ -338,13 +338,13 @@ impl<T: Ord> BinaryHeap<T> {
/// assert!(heap.capacity() >= 100);
/// heap.push(4u);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve(&mut self, additional: uint) {
self.data.reserve(additional);
}
/// Discards as much additional capacity as possible.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn shrink_to_fit(&mut self) {
self.data.shrink_to_fit();
}
@ -362,7 +362,7 @@ impl<T: Ord> BinaryHeap<T> {
/// assert_eq!(heap.pop(), Some(1));
/// assert_eq!(heap.pop(), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn pop(&mut self) -> Option<T> {
self.data.pop().map(|mut item| {
if !self.is_empty() {
@ -387,7 +387,7 @@ impl<T: Ord> BinaryHeap<T> {
/// assert_eq!(heap.len(), 3);
/// assert_eq!(heap.peek(), Some(&5));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn push(&mut self, item: T) {
let old_len = self.len();
self.data.push(item);
@ -542,40 +542,41 @@ impl<T: Ord> BinaryHeap<T> {
}
/// Returns the length of the binary heap.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint { self.data.len() }
/// Checks if the binary heap is empty.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool { self.len() == 0 }
/// Clears the binary heap, returning an iterator over the removed elements.
#[inline]
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<T> {
Drain { iter: self.data.drain() }
}
/// Drops all items from the binary heap.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn clear(&mut self) { self.drain(); }
}
/// `BinaryHeap` iterator.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Iter <'a, T: 'a> {
iter: slice::Iter<'a, T>,
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Clone for Iter<'a, T> {
fn clone(&self) -> Iter<'a, T> {
Iter { iter: self.iter.clone() }
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
@ -586,22 +587,22 @@ impl<'a, T> Iterator for Iter<'a, T> {
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a T> { self.iter.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
/// An iterator that moves out of a `BinaryHeap`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IntoIter<T> {
iter: vec::IntoIter<T>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Iterator for IntoIter<T> {
type Item = T;
@ -612,22 +613,22 @@ impl<T> Iterator for IntoIter<T> {
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
#[inline]
fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> ExactSizeIterator for IntoIter<T> {}
/// An iterator that drains a `BinaryHeap`.
#[unstable = "recent addition"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recent addition")]
pub struct Drain<'a, T: 'a> {
iter: vec::Drain<'a, T>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: 'a> Iterator for Drain<'a, T> {
type Item = T;
@ -638,23 +639,23 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
fn from_iter<Iter: Iterator<Item=T>>(iter: Iter) -> BinaryHeap<T> {
BinaryHeap::from_vec(iter.collect())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Ord> Extend<T> for BinaryHeap<T> {
fn extend<Iter: Iterator<Item=T>>(&mut self, mut iter: Iter) {
let (lower, _) = iter.size_hint();

141
src/libcollections/bit.rs
View File

@ -156,7 +156,8 @@ static FALSE: bool = false;
/// println!("{:?}", bv);
/// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
/// ```
#[unstable = "RFC 509"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "RFC 509")]
pub struct Bitv {
/// Internal representation of the bit vector
storage: Vec<u32>,
@ -252,7 +253,7 @@ impl Bitv {
/// use std::collections::Bitv;
/// let mut bv = Bitv::new();
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> Bitv {
Bitv { storage: Vec::new(), nbits: 0 }
}
@ -288,7 +289,7 @@ impl Bitv {
///
/// It is important to note that this function does not specify the
/// *length* of the returned bitvector, but only the *capacity*.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn with_capacity(nbits: uint) -> Bitv {
Bitv {
storage: Vec::with_capacity(blocks_for_bits(nbits)),
@ -374,7 +375,7 @@ impl Bitv {
/// assert_eq!(bv[1], true);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn get(&self, i: uint) -> Option<bool> {
if i >= self.nbits {
return None;
@ -402,7 +403,8 @@ impl Bitv {
/// assert_eq!(bv[3], true);
/// ```
#[inline]
#[unstable = "panic semantics are likely to change in the future"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "panic semantics are likely to change in the future")]
pub fn set(&mut self, i: uint, x: bool) {
assert!(i < self.nbits);
let w = i / u32::BITS;
@ -585,7 +587,7 @@ impl Bitv {
/// assert_eq!(bv.iter().filter(|x| *x).count(), 7);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter(&self) -> Iter {
Iter { bitv: self, next_idx: 0, end_idx: self.nbits }
}
@ -706,7 +708,7 @@ impl Bitv {
/// bv.truncate(2);
/// assert!(bv.eq_vec(&[false, true]));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn truncate(&mut self, len: uint) {
if len < self.len() {
self.nbits = len;
@ -733,7 +735,7 @@ impl Bitv {
/// assert_eq!(bv.len(), 3);
/// assert!(bv.capacity() >= 13);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve(&mut self, additional: uint) {
let desired_cap = self.len().checked_add(additional).expect("capacity overflow");
let storage_len = self.storage.len();
@ -763,7 +765,7 @@ impl Bitv {
/// assert_eq!(bv.len(), 3);
/// assert!(bv.capacity() >= 13);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve_exact(&mut self, additional: uint) {
let desired_cap = self.len().checked_add(additional).expect("capacity overflow");
let storage_len = self.storage.len();
@ -785,7 +787,7 @@ impl Bitv {
/// assert!(bv.capacity() >= 10);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn capacity(&self) -> uint {
self.storage.capacity().checked_mul(u32::BITS).unwrap_or(uint::MAX)
}
@ -856,7 +858,7 @@ impl Bitv {
/// assert_eq!(bv.pop(), Some(false));
/// assert_eq!(bv.len(), 6);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn pop(&mut self) -> Option<bool> {
if self.is_empty() {
None
@ -886,7 +888,7 @@ impl Bitv {
/// bv.push(false);
/// assert!(bv.eq_vec(&[true, false]));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn push(&mut self, elem: bool) {
if self.nbits % u32::BITS == 0 {
self.storage.push(0);
@ -898,29 +900,29 @@ impl Bitv {
/// Return the total number of bits in this vector
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint { self.nbits }
/// Returns true if there are no bits in this vector
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool { self.len() == 0 }
/// Clears all bits in this vector.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn clear(&mut self) {
for w in self.storage.iter_mut() { *w = 0u32; }
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Default for Bitv {
#[inline]
fn default() -> Bitv { Bitv::new() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl FromIterator<bool> for Bitv {
fn from_iter<I:Iterator<Item=bool>>(iterator: I) -> Bitv {
let mut ret = Bitv::new();
@ -929,7 +931,7 @@ impl FromIterator<bool> for Bitv {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Extend<bool> for Bitv {
#[inline]
fn extend<I: Iterator<Item=bool>>(&mut self, mut iterator: I) {
@ -941,7 +943,7 @@ impl Extend<bool> for Bitv {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Clone for Bitv {
#[inline]
fn clone(&self) -> Bitv {
@ -955,7 +957,7 @@ impl Clone for Bitv {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialOrd for Bitv {
#[inline]
fn partial_cmp(&self, other: &Bitv) -> Option<Ordering> {
@ -963,7 +965,7 @@ impl PartialOrd for Bitv {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Ord for Bitv {
#[inline]
fn cmp(&self, other: &Bitv) -> Ordering {
@ -971,7 +973,7 @@ impl Ord for Bitv {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl fmt::Show for Bitv {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
for bit in self.iter() {
@ -981,7 +983,7 @@ impl fmt::Show for Bitv {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for Bitv {
fn hash(&self, state: &mut S) {
self.nbits.hash(state);
@ -991,7 +993,7 @@ impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for Bitv {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl cmp::PartialEq for Bitv {
#[inline]
fn eq(&self, other: &Bitv) -> bool {
@ -1002,11 +1004,11 @@ impl cmp::PartialEq for Bitv {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl cmp::Eq for Bitv {}
/// An iterator for `Bitv`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[derive(Clone)]
pub struct Iter<'a> {
bitv: &'a Bitv,
@ -1014,7 +1016,7 @@ pub struct Iter<'a> {
end_idx: uint,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for Iter<'a> {
type Item = bool;
@ -1035,7 +1037,7 @@ impl<'a> Iterator for Iter<'a> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> DoubleEndedIterator for Iter<'a> {
#[inline]
fn next_back(&mut self) -> Option<bool> {
@ -1048,10 +1050,10 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> ExactSizeIterator for Iter<'a> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> RandomAccessIterator for Iter<'a> {
#[inline]
fn indexable(&self) -> uint {
@ -1107,18 +1109,19 @@ impl<'a> RandomAccessIterator for Iter<'a> {
/// assert!(bv[3]);
/// ```
#[derive(Clone)]
#[unstable = "RFC 509"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "RFC 509")]
pub struct BitvSet {
bitv: Bitv,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Default for BitvSet {
#[inline]
fn default() -> BitvSet { BitvSet::new() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl FromIterator<uint> for BitvSet {
fn from_iter<I:Iterator<Item=uint>>(iterator: I) -> BitvSet {
let mut ret = BitvSet::new();
@ -1127,7 +1130,7 @@ impl FromIterator<uint> for BitvSet {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Extend<uint> for BitvSet {
#[inline]
fn extend<I: Iterator<Item=uint>>(&mut self, mut iterator: I) {
@ -1137,7 +1140,7 @@ impl Extend<uint> for BitvSet {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialOrd for BitvSet {
#[inline]
fn partial_cmp(&self, other: &BitvSet) -> Option<Ordering> {
@ -1146,7 +1149,7 @@ impl PartialOrd for BitvSet {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Ord for BitvSet {
#[inline]
fn cmp(&self, other: &BitvSet) -> Ordering {
@ -1155,7 +1158,7 @@ impl Ord for BitvSet {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl cmp::PartialEq for BitvSet {
#[inline]
fn eq(&self, other: &BitvSet) -> bool {
@ -1164,7 +1167,7 @@ impl cmp::PartialEq for BitvSet {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl cmp::Eq for BitvSet {}
impl BitvSet {
@ -1178,7 +1181,7 @@ impl BitvSet {
/// let mut s = BitvSet::new();
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> BitvSet {
BitvSet { bitv: Bitv::new() }
}
@ -1195,7 +1198,7 @@ impl BitvSet {
/// assert!(s.capacity() >= 100);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn with_capacity(nbits: uint) -> BitvSet {
let bitv = Bitv::from_elem(nbits, false);
BitvSet::from_bitv(bitv)
@ -1233,7 +1236,7 @@ impl BitvSet {
/// assert!(s.capacity() >= 100);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn capacity(&self) -> uint {
self.bitv.capacity()
}
@ -1254,7 +1257,7 @@ impl BitvSet {
/// s.reserve_len(10);
/// assert!(s.capacity() >= 10);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve_len(&mut self, len: uint) {
let cur_len = self.bitv.len();
if len >= cur_len {
@ -1280,7 +1283,7 @@ impl BitvSet {
/// s.reserve_len_exact(10);
/// assert!(s.capacity() >= 10);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve_len_exact(&mut self, len: uint) {
let cur_len = self.bitv.len();
if len >= cur_len {
@ -1374,7 +1377,7 @@ impl BitvSet {
/// println!("new capacity: {}", s.capacity());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn shrink_to_fit(&mut self) {
let bitv = &mut self.bitv;
// Obtain original length
@ -1402,7 +1405,7 @@ impl BitvSet {
/// }
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter(&self) -> bitv_set::Iter {
SetIter {set: self, next_idx: 0u}
}
@ -1424,7 +1427,7 @@ impl BitvSet {
/// }
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn union<'a>(&'a self, other: &'a BitvSet) -> Union<'a> {
fn or(w1: u32, w2: u32) -> u32 { w1 | w2 }
@ -1454,7 +1457,7 @@ impl BitvSet {
/// }
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn intersection<'a>(&'a self, other: &'a BitvSet) -> Intersection<'a> {
fn bitand(w1: u32, w2: u32) -> u32 { w1 & w2 }
let min = cmp::min(self.bitv.len(), other.bitv.len());
@ -1491,7 +1494,7 @@ impl BitvSet {
/// }
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn difference<'a>(&'a self, other: &'a BitvSet) -> Difference<'a> {
fn diff(w1: u32, w2: u32) -> u32 { w1 & !w2 }
@ -1522,7 +1525,7 @@ impl BitvSet {
/// }
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn symmetric_difference<'a>(&'a self, other: &'a BitvSet) -> SymmetricDifference<'a> {
fn bitxor(w1: u32, w2: u32) -> u32 { w1 ^ w2 }
@ -1639,28 +1642,28 @@ impl BitvSet {
/// Return the number of set bits in this set.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint {
self.bitv.blocks().fold(0, |acc, n| acc + n.count_ones())
}
/// Returns whether there are no bits set in this set
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool {
self.bitv.none()
}
/// Clears all bits in this set
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn clear(&mut self) {
self.bitv.clear();
}
/// Returns `true` if this set contains the specified integer.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn contains(&self, value: &uint) -> bool {
let bitv = &self.bitv;
*value < bitv.nbits && bitv[*value]
@ -1669,14 +1672,14 @@ impl BitvSet {
/// Returns `true` if the set has no elements in common with `other`.
/// This is equivalent to checking for an empty intersection.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_disjoint(&self, other: &BitvSet) -> bool {
self.intersection(other).next().is_none()
}
/// Returns `true` if the set is a subset of another.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_subset(&self, other: &BitvSet) -> bool {
let self_bitv = &self.bitv;
let other_bitv = &other.bitv;
@ -1690,14 +1693,14 @@ impl BitvSet {
/// Returns `true` if the set is a superset of another.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_superset(&self, other: &BitvSet) -> bool {
other.is_subset(self)
}
/// Adds a value to the set. Returns `true` if the value was not already
/// present in the set.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn insert(&mut self, value: uint) -> bool {
if self.contains(&value) {
return false;
@ -1715,7 +1718,7 @@ impl BitvSet {
/// Removes a value from the set. Returns `true` if the value was
/// present in the set.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn remove(&mut self, value: &uint) -> bool {
if !self.contains(value) {
return false;
@ -1752,7 +1755,7 @@ impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for BitvSet {
/// An iterator for `BitvSet`.
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct SetIter<'a> {
set: &'a BitvSet,
next_idx: uint
@ -1768,16 +1771,16 @@ struct TwoBitPositions<'a> {
next_idx: uint
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Union<'a>(TwoBitPositions<'a>);
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Intersection<'a>(Take<TwoBitPositions<'a>>);
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Difference<'a>(TwoBitPositions<'a>);
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct SymmetricDifference<'a>(TwoBitPositions<'a>);
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for SetIter<'a> {
type Item = uint;
@ -1800,7 +1803,7 @@ impl<'a> Iterator for SetIter<'a> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for TwoBitPositions<'a> {
type Item = uint;
@ -1838,7 +1841,7 @@ impl<'a> Iterator for TwoBitPositions<'a> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for Union<'a> {
type Item = uint;
@ -1846,7 +1849,7 @@ impl<'a> Iterator for Union<'a> {
#[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for Intersection<'a> {
type Item = uint;
@ -1854,7 +1857,7 @@ impl<'a> Iterator for Intersection<'a> {
#[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for Difference<'a> {
type Item = uint;
@ -1862,7 +1865,7 @@ impl<'a> Iterator for Difference<'a> {
#[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for SymmetricDifference<'a> {
type Item = uint;

133
src/libcollections/btree/map.rs
View File

@ -81,7 +81,7 @@ use super::node::{self, Node, Found, GoDown};
/// done on each operation isn't *catastrophic*, and *is* still bounded by O(B log<sub>B</sub>n),
/// it is certainly much slower when it does.
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct BTreeMap<K, V> {
root: Node<K, V>,
length: uint,
@ -96,31 +96,31 @@ struct AbsIter<T> {
}
/// An iterator over a BTreeMap's entries.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Iter<'a, K: 'a, V: 'a> {
inner: AbsIter<Traversal<'a, K, V>>
}
/// A mutable iterator over a BTreeMap's entries.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IterMut<'a, K: 'a, V: 'a> {
inner: AbsIter<MutTraversal<'a, K, V>>
}
/// An owning iterator over a BTreeMap's entries.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IntoIter<K, V> {
inner: AbsIter<MoveTraversal<K, V>>
}
/// An iterator over a BTreeMap's keys.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Keys<'a, K: 'a, V: 'a> {
inner: Map<(&'a K, &'a V), &'a K, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a K>
}
/// An iterator over a BTreeMap's values.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Values<'a, K: 'a, V: 'a> {
inner: Map<(&'a K, &'a V), &'a V, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a V>
}
@ -136,7 +136,8 @@ pub struct RangeMut<'a, K: 'a, V: 'a> {
}
/// A view into a single entry in a map, which may either be vacant or occupied.
#[unstable = "precise API still under development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "precise API still under development")]
pub enum Entry<'a, K:'a, V:'a> {
/// A vacant Entry
Vacant(VacantEntry<'a, K, V>),
@ -145,21 +146,23 @@ pub enum Entry<'a, K:'a, V:'a> {
}
/// A vacant Entry.
#[unstable = "precise API still under development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "precise API still under development")]
pub struct VacantEntry<'a, K:'a, V:'a> {
key: K,
stack: stack::SearchStack<'a, K, V, node::handle::Edge, node::handle::Leaf>,
}
/// An occupied Entry.
#[unstable = "precise API still under development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "precise API still under development")]
pub struct OccupiedEntry<'a, K:'a, V:'a> {
stack: stack::SearchStack<'a, K, V, node::handle::KV, node::handle::LeafOrInternal>,
}
impl<K: Ord, V> BTreeMap<K, V> {
/// Makes a new empty BTreeMap with a reasonable choice for B.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> BTreeMap<K, V> {
//FIXME(Gankro): Tune this as a function of size_of<K/V>?
BTreeMap::with_b(6)
@ -190,7 +193,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// a.clear();
/// assert!(a.is_empty());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn clear(&mut self) {
let b = self.b;
// avoid recursive destructors by manually traversing the tree
@ -220,7 +223,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(map.get(&1), Some(&"a"));
/// assert_eq!(map.get(&2), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V> where Q: BorrowFrom<K> + Ord {
let mut cur_node = &self.root;
loop {
@ -252,7 +255,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(map.contains_key(&1), true);
/// assert_eq!(map.contains_key(&2), false);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool where Q: BorrowFrom<K> + Ord {
self.get(key).is_some()
}
@ -276,7 +279,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(map[1], "b");
/// ```
// See `get` for implementation notes, this is basically a copy-paste with mut's added
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V> where Q: BorrowFrom<K> + Ord {
// temp_node is a Borrowck hack for having a mutable value outlive a loop iteration
let mut temp_node = &mut self.root;
@ -337,7 +340,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(map.insert(37, "c"), Some("b"));
/// assert_eq!(map[37], "c");
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn insert(&mut self, mut key: K, mut value: V) -> Option<V> {
// This is a stack of rawptrs to nodes paired with indices, respectively
// representing the nodes and edges of our search path. We have to store rawptrs
@ -446,7 +449,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(map.remove(&1), Some("a"));
/// assert_eq!(map.remove(&1), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where Q: BorrowFrom<K> + Ord {
// See `swap` for a more thorough description of the stuff going on in here
let mut stack = stack::PartialSearchStack::new(self);
@ -807,7 +810,7 @@ mod stack {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V> {
fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> BTreeMap<K, V> {
let mut map = BTreeMap::new();
@ -816,7 +819,7 @@ impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {
#[inline]
fn extend<T: Iterator<Item=(K, V)>>(&mut self, mut iter: T) {
@ -826,7 +829,7 @@ impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<S: Hasher, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> {
fn hash(&self, state: &mut S) {
for elt in self.iter() {
@ -835,15 +838,15 @@ impl<S: Hasher, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: Ord, V> Default for BTreeMap<K, V> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> BTreeMap<K, V> {
BTreeMap::new()
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: PartialEq, V: PartialEq> PartialEq for BTreeMap<K, V> {
fn eq(&self, other: &BTreeMap<K, V>) -> bool {
self.len() == other.len() &&
@ -851,10 +854,10 @@ impl<K: PartialEq, V: PartialEq> PartialEq for BTreeMap<K, V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: Eq, V: Eq> Eq for BTreeMap<K, V> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: PartialOrd, V: PartialOrd> PartialOrd for BTreeMap<K, V> {
#[inline]
fn partial_cmp(&self, other: &BTreeMap<K, V>) -> Option<Ordering> {
@ -862,7 +865,7 @@ impl<K: PartialOrd, V: PartialOrd> PartialOrd for BTreeMap<K, V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: Ord, V: Ord> Ord for BTreeMap<K, V> {
#[inline]
fn cmp(&self, other: &BTreeMap<K, V>) -> Ordering {
@ -870,7 +873,7 @@ impl<K: Ord, V: Ord> Ord for BTreeMap<K, V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: Show, V: Show> Show for BTreeMap<K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "BTreeMap {{"));
@ -884,7 +887,7 @@ impl<K: Show, V: Show> Show for BTreeMap<K, V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
where Q: BorrowFrom<K> + Ord
{
@ -895,7 +898,7 @@ impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: Ord, Q: ?Sized, V> IndexMut<Q> for BTreeMap<K, V>
where Q: BorrowFrom<K> + Ord
{
@ -1006,75 +1009,75 @@ impl<K, V, E, T> DoubleEndedIterator for AbsIter<T> where
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> Iterator for Iter<'a, K, V> {
type Item = (&'a K, &'a V);
fn next(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> {
fn next_back(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> Iterator for IterMut<'a, K, V> {
type Item = (&'a K, &'a mut V);
fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> {
fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
fn next_back(&mut self) -> Option<(K, V)> { self.inner.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K, V> ExactSizeIterator for IntoIter<K, V> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> Iterator for Keys<'a, K, V> {
type Item = &'a K;
fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
fn next_back(&mut self) -> Option<(&'a K)> { self.inner.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> Iterator for Values<'a, K, V> {
type Item = &'a V;
fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
fn next_back(&mut self) -> Option<(&'a V)> { self.inner.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
impl<'a, K, V> Iterator for Range<'a, K, V> {
@ -1096,7 +1099,8 @@ impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V> {
}
impl<'a, K: Ord, V> Entry<'a, K, V> {
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform v2 specification, waiting for dust to settle")]
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> {
match self {
@ -1109,7 +1113,8 @@ impl<'a, K: Ord, V> Entry<'a, K, V> {
impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
/// Sets the value of the entry with the VacantEntry's key,
/// and returns a mutable reference to it.
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn insert(self, value: V) -> &'a mut V {
self.stack.insert(self.key, value)
}
@ -1117,33 +1122,38 @@ impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
/// Gets a reference to the value in the entry.
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn get(&self) -> &V {
self.stack.peek()
}
/// Gets a mutable reference to the value in the entry.
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn get_mut(&mut self) -> &mut V {
self.stack.peek_mut()
}
/// Converts the entry into a mutable reference to its value.
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn into_mut(self) -> &'a mut V {
self.stack.into_top()
}
/// Sets the value of the entry with the OccupiedEntry's key,
/// and returns the entry's old value.
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn insert(&mut self, mut value: V) -> V {
mem::swap(self.stack.peek_mut(), &mut value);
value
}
/// Takes the value of the entry out of the map, and returns it.
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform v2 specification, waiting for dust to settle")]
pub fn remove(self) -> V {
self.stack.remove()
}
@ -1169,7 +1179,7 @@ impl<K, V> BTreeMap<K, V> {
/// let (first_key, first_value) = map.iter().next().unwrap();
/// assert_eq!((*first_key, *first_value), (1u, "a"));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter(&self) -> Iter<K, V> {
let len = self.len();
// NB. The initial capacity for ringbuf is large enough to avoid reallocs in many cases.
@ -1202,7 +1212,7 @@ impl<K, V> BTreeMap<K, V> {
/// }
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter_mut(&mut self) -> IterMut<K, V> {
let len = self.len();
let mut lca = RingBuf::new();
@ -1231,7 +1241,7 @@ impl<K, V> BTreeMap<K, V> {
/// println!("{}: {}", key, value);
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<K, V> {
let len = self.len();
let mut lca = RingBuf::new();
@ -1258,7 +1268,7 @@ impl<K, V> BTreeMap<K, V> {
/// let keys: Vec<uint> = a.keys().cloned().collect();
/// assert_eq!(keys, vec![1u,2,]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
fn first<A, B>((a, _): (A, B)) -> A { a }
let first: fn((&'a K, &'a V)) -> &'a K = first; // coerce to fn pointer
@ -1280,7 +1290,7 @@ impl<K, V> BTreeMap<K, V> {
/// let values: Vec<&str> = a.values().cloned().collect();
/// assert_eq!(values, vec!["a","b"]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn values<'a>(&'a self) -> Values<'a, K, V> {
fn second<A, B>((_, b): (A, B)) -> B { b }
let second: fn((&'a K, &'a V)) -> &'a V = second; // coerce to fn pointer
@ -1300,7 +1310,7 @@ impl<K, V> BTreeMap<K, V> {
/// a.insert(1u, "a");
/// assert_eq!(a.len(), 1);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint { self.length }
/// Return true if the map contains no elements.
@ -1315,7 +1325,7 @@ impl<K, V> BTreeMap<K, V> {
/// a.insert(1u, "a");
/// assert!(!a.is_empty());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool { self.len() == 0 }
}
@ -1470,7 +1480,8 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// }
/// assert_eq!(Some((&5u, &"b")), map.range(Included(&4), Unbounded).next());
/// ```
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn range<'a>(&'a self, min: Bound<&K>, max: Bound<&K>) -> Range<'a, K, V> {
range_impl!(&self.root, min, max, as_slices_internal, iter, Range, edges, [])
}
@ -1496,7 +1507,8 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// println!("{} => {}", name, balance);
/// }
/// ```
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn range_mut<'a>(&'a mut self, min: Bound<&K>, max: Bound<&K>) -> RangeMut<'a, K, V> {
range_impl!(&mut self.root, min, max, as_slices_internal_mut, iter_mut, RangeMut,
edges_mut, [mut])
@ -1528,7 +1540,8 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(count["a"], 3u);
/// ```
/// The key must have the same ordering before or after `.to_owned()` is called.
#[unstable = "precise API still under development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "precise API still under development")]
pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> {
// same basic logic of `swap` and `pop`, blended together
let mut stack = stack::PartialSearchStack::new(self);

2
src/libcollections/btree/node.rs
View File

@ -420,7 +420,7 @@ impl<K, V> Node<K, V> {
}
// FIXME(gereeter) Write an efficient clone_from
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<K: Clone, V: Clone> Clone for Node<K, V> {
fn clone(&self) -> Node<K, V> {
let mut ret = if self.is_leaf() {

90
src/libcollections/btree/set.rs
View File

@ -34,19 +34,19 @@ use Bound;
/// See BTreeMap's documentation for a detailed discussion of this collection's performance
/// benefits and drawbacks.
#[derive(Clone, Hash, PartialEq, Eq, Ord, PartialOrd)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct BTreeSet<T>{
map: BTreeMap<T, ()>,
}
/// An iterator over a BTreeSet's items.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Iter<'a, T: 'a> {
iter: Keys<'a, T, ()>
}
/// An owning iterator over a BTreeSet's items.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IntoIter<T> {
iter: Map<(T, ()), T, ::btree_map::IntoIter<T, ()>, fn((T, ())) -> T>
}
@ -57,28 +57,28 @@ pub struct Range<'a, T: 'a> {
}
/// A lazy iterator producing elements in the set difference (in-order).
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Difference<'a, T:'a> {
a: Peekable<&'a T, Iter<'a, T>>,
b: Peekable<&'a T, Iter<'a, T>>,
}
/// A lazy iterator producing elements in the set symmetric difference (in-order).
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct SymmetricDifference<'a, T:'a> {
a: Peekable<&'a T, Iter<'a, T>>,
b: Peekable<&'a T, Iter<'a, T>>,
}
/// A lazy iterator producing elements in the set intersection (in-order).
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Intersection<'a, T:'a> {
a: Peekable<&'a T, Iter<'a, T>>,
b: Peekable<&'a T, Iter<'a, T>>,
}
/// A lazy iterator producing elements in the set union (in-order).
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Union<'a, T:'a> {
a: Peekable<&'a T, Iter<'a, T>>,
b: Peekable<&'a T, Iter<'a, T>>,
@ -94,7 +94,7 @@ impl<T: Ord> BTreeSet<T> {
///
/// let mut set: BTreeSet<int> = BTreeSet::new();
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> BTreeSet<T> {
BTreeSet { map: BTreeMap::new() }
}
@ -102,7 +102,8 @@ impl<T: Ord> BTreeSet<T> {
/// Makes a new BTreeSet with the given B.
///
/// B cannot be less than 2.
#[unstable = "probably want this to be on the type, eventually"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "probably want this to be on the type, eventually")]
pub fn with_b(b: uint) -> BTreeSet<T> {
BTreeSet { map: BTreeMap::with_b(b) }
}
@ -125,7 +126,7 @@ impl<T> BTreeSet<T> {
/// let v: Vec<uint> = set.iter().map(|&x| x).collect();
/// assert_eq!(v, vec![1u,2,3,4]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
Iter { iter: self.map.keys() }
}
@ -142,7 +143,7 @@ impl<T> BTreeSet<T> {
/// let v: Vec<uint> = set.into_iter().collect();
/// assert_eq!(v, vec![1u,2,3,4]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<T> {
fn first<A, B>((a, _): (A, B)) -> A { a }
let first: fn((T, ())) -> T = first; // coerce to fn pointer
@ -172,7 +173,8 @@ impl<T: Ord> BTreeSet<T> {
/// }
/// assert_eq!(Some(&5u), set.range(Included(&4), Unbounded).next());
/// ```
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn range<'a>(&'a self, min: Bound<&T>, max: Bound<&T>) -> Range<'a, T> {
fn first<A, B>((a, _): (A, B)) -> A { a }
let first: fn((&'a T, &'a ())) -> &'a T = first; // coerce to fn pointer
@ -200,7 +202,7 @@ impl<T: Ord> BTreeSet<T> {
/// let diff: Vec<uint> = a.difference(&b).cloned().collect();
/// assert_eq!(diff, vec![1u]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T> {
Difference{a: self.iter().peekable(), b: other.iter().peekable()}
}
@ -223,7 +225,7 @@ impl<T: Ord> BTreeSet<T> {
/// let sym_diff: Vec<uint> = a.symmetric_difference(&b).cloned().collect();
/// assert_eq!(sym_diff, vec![1u,3]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>)
-> SymmetricDifference<'a, T> {
SymmetricDifference{a: self.iter().peekable(), b: other.iter().peekable()}
@ -247,7 +249,7 @@ impl<T: Ord> BTreeSet<T> {
/// let intersection: Vec<uint> = a.intersection(&b).cloned().collect();
/// assert_eq!(intersection, vec![2u]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>)
-> Intersection<'a, T> {
Intersection{a: self.iter().peekable(), b: other.iter().peekable()}
@ -269,7 +271,7 @@ impl<T: Ord> BTreeSet<T> {
/// let union: Vec<uint> = a.union(&b).cloned().collect();
/// assert_eq!(union, vec![1u,2]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T> {
Union{a: self.iter().peekable(), b: other.iter().peekable()}
}
@ -286,7 +288,7 @@ impl<T: Ord> BTreeSet<T> {
/// v.insert(1i);
/// assert_eq!(v.len(), 1);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint { self.map.len() }
/// Returns true if the set contains no elements
@ -301,7 +303,7 @@ impl<T: Ord> BTreeSet<T> {
/// v.insert(1i);
/// assert!(!v.is_empty());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool { self.len() == 0 }
/// Clears the set, removing all values.
@ -316,7 +318,7 @@ impl<T: Ord> BTreeSet<T> {
/// v.clear();
/// assert!(v.is_empty());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn clear(&mut self) {
self.map.clear()
}
@ -336,7 +338,7 @@ impl<T: Ord> BTreeSet<T> {
/// assert_eq!(set.contains(&1), true);
/// assert_eq!(set.contains(&4), false);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool where Q: BorrowFrom<T> + Ord {
self.map.contains_key(value)
}
@ -358,7 +360,7 @@ impl<T: Ord> BTreeSet<T> {
/// b.insert(1);
/// assert_eq!(a.is_disjoint(&b), false);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_disjoint(&self, other: &BTreeSet<T>) -> bool {
self.intersection(other).next().is_none()
}
@ -379,7 +381,7 @@ impl<T: Ord> BTreeSet<T> {
/// set.insert(4);
/// assert_eq!(set.is_subset(&sup), false);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_subset(&self, other: &BTreeSet<T>) -> bool {
// Stolen from TreeMap
let mut x = self.iter();
@ -424,7 +426,7 @@ impl<T: Ord> BTreeSet<T> {
/// set.insert(2);
/// assert_eq!(set.is_superset(&sub), true);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_superset(&self, other: &BTreeSet<T>) -> bool {
other.is_subset(self)
}
@ -443,7 +445,7 @@ impl<T: Ord> BTreeSet<T> {
/// assert_eq!(set.insert(2i), false);
/// assert_eq!(set.len(), 1);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn insert(&mut self, value: T) -> bool {
self.map.insert(value, ()).is_none()
}
@ -466,13 +468,13 @@ impl<T: Ord> BTreeSet<T> {
/// assert_eq!(set.remove(&2), true);
/// assert_eq!(set.remove(&2), false);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool where Q: BorrowFrom<T> + Ord {
self.map.remove(value).is_some()
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Ord> FromIterator<T> for BTreeSet<T> {
fn from_iter<Iter: Iterator<Item=T>>(iter: Iter) -> BTreeSet<T> {
let mut set = BTreeSet::new();
@ -481,7 +483,7 @@ impl<T: Ord> FromIterator<T> for BTreeSet<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Ord> Extend<T> for BTreeSet<T> {
#[inline]
fn extend<Iter: Iterator<Item=T>>(&mut self, mut iter: Iter) {
@ -491,15 +493,15 @@ impl<T: Ord> Extend<T> for BTreeSet<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Ord> Default for BTreeSet<T> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> BTreeSet<T> {
BTreeSet::new()
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet<T>> for &'a BTreeSet<T> {
type Output = BTreeSet<T>;
@ -522,7 +524,7 @@ impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet<T>> for &'a BTreeSet<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet<T>> for &'a BTreeSet<T> {
type Output = BTreeSet<T>;
@ -545,7 +547,7 @@ impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet<T>> for &'a BTreeSet<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet<T>> for &'a BTreeSet<T> {
type Output = BTreeSet<T>;
@ -568,7 +570,7 @@ impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet<T>> for &'a BTreeSet<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> {
type Output = BTreeSet<T>;
@ -591,7 +593,7 @@ impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Show> Show for BTreeSet<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "BTreeSet {{"));
@ -605,33 +607,33 @@ impl<T: Show> Show for BTreeSet<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
fn next(&mut self) -> Option<&'a T> { self.iter.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
fn next_back(&mut self) -> Option<&'a T> { self.iter.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Iterator for IntoIter<T> {
type Item = T;
fn next(&mut self) -> Option<T> { self.iter.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> ExactSizeIterator for IntoIter<T> {}
@ -654,7 +656,7 @@ fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>,
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: Ord> Iterator for Difference<'a, T> {
type Item = &'a T;
@ -669,7 +671,7 @@ impl<'a, T: Ord> Iterator for Difference<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T> {
type Item = &'a T;
@ -684,7 +686,7 @@ impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: Ord> Iterator for Intersection<'a, T> {
type Item = &'a T;
@ -705,7 +707,7 @@ impl<'a, T: Ord> Iterator for Intersection<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: Ord> Iterator for Union<'a, T> {
type Item = &'a T;

90
src/libcollections/dlist.rs
View File

@ -19,7 +19,7 @@
// Backlinks over DList::prev are raw pointers that form a full chain in
// the reverse direction.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use core::prelude::*;
@ -33,7 +33,7 @@ use core::mem;
use core::ptr;
/// A doubly-linked list.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct DList<T> {
length: uint,
list_head: Link<T>,
@ -57,7 +57,7 @@ struct Node<T> {
}
/// An iterator over references to the items of a `DList`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Iter<'a, T:'a> {
head: &'a Link<T>,
tail: Rawlink<Node<T>>,
@ -65,7 +65,7 @@ pub struct Iter<'a, T:'a> {
}
// FIXME #19839: deriving is too aggressive on the bounds (T doesn't need to be Clone).
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Clone for Iter<'a, T> {
fn clone(&self) -> Iter<'a, T> {
Iter {
@ -77,7 +77,7 @@ impl<'a, T> Clone for Iter<'a, T> {
}
/// An iterator over mutable references to the items of a `DList`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IterMut<'a, T:'a> {
list: &'a mut DList<T>,
head: Rawlink<Node<T>>,
@ -87,7 +87,7 @@ pub struct IterMut<'a, T:'a> {
/// An iterator over mutable references to the items of a `DList`.
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IntoIter<T> {
list: DList<T>
}
@ -206,17 +206,17 @@ impl<T> DList<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Default for DList<T> {
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> DList<T> { DList::new() }
}
impl<T> DList<T> {
/// Creates an empty `DList`.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> DList<T> {
DList{list_head: None, list_tail: Rawlink::none(), length: 0}
}
@ -273,14 +273,14 @@ impl<T> DList<T> {
/// Provides a forward iterator.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
Iter{nelem: self.len(), head: &self.list_head, tail: self.list_tail}
}
/// Provides a forward iterator with mutable references.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter_mut(&mut self) -> IterMut<T> {
let head_raw = match self.list_head {
Some(ref mut h) => Rawlink::some(&mut **h),
@ -296,7 +296,7 @@ impl<T> DList<T> {
/// Consumes the list into an iterator yielding elements by value.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<T> {
IntoIter{list: self}
}
@ -317,7 +317,7 @@ impl<T> DList<T> {
/// assert!(!dl.is_empty());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool {
self.list_head.is_none()
}
@ -344,7 +344,7 @@ impl<T> DList<T> {
///
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint {
self.length
}
@ -371,7 +371,7 @@ impl<T> DList<T> {
///
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn clear(&mut self) {
*self = DList::new()
}
@ -392,7 +392,7 @@ impl<T> DList<T> {
///
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn front(&self) -> Option<&T> {
self.list_head.as_ref().map(|head| &head.value)
}
@ -419,7 +419,7 @@ impl<T> DList<T> {
///
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn front_mut(&mut self) -> Option<&mut T> {
self.list_head.as_mut().map(|head| &mut head.value)
}
@ -440,7 +440,7 @@ impl<T> DList<T> {
///
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn back(&self) -> Option<&T> {
self.list_tail.resolve_immut().as_ref().map(|tail| &tail.value)
}
@ -467,7 +467,7 @@ impl<T> DList<T> {
///
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn back_mut(&mut self) -> Option<&mut T> {
self.list_tail.resolve().map(|tail| &mut tail.value)
}
@ -490,7 +490,7 @@ impl<T> DList<T> {
/// assert_eq!(dl.front().unwrap(), &1);
///
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn push_front(&mut self, elt: T) {
self.push_front_node(box Node::new(elt))
}
@ -516,7 +516,7 @@ impl<T> DList<T> {
///
/// ```
///
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn pop_front(&mut self) -> Option<T> {
self.pop_front_node().map(|box Node{value, ..}| value)
}
@ -533,7 +533,7 @@ impl<T> DList<T> {
/// d.push_back(3);
/// assert_eq!(3, *d.back().unwrap());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn push_back(&mut self, elt: T) {
self.push_back_node(box Node::new(elt))
}
@ -552,7 +552,7 @@ impl<T> DList<T> {
/// d.push_back(3);
/// assert_eq!(d.pop_back(), Some(3));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn pop_back(&mut self) -> Option<T> {
self.pop_back_node().map(|box Node{value, ..}| value)
}
@ -577,7 +577,7 @@ impl<T> DList<T> {
/// assert_eq!(splitted.pop_front(), Some(1));
/// assert_eq!(splitted.pop_front(), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn split_off(&mut self, at: uint) -> DList<T> {
let len = self.len();
assert!(at < len, "Cannot split off at a nonexistent index");
@ -620,7 +620,7 @@ impl<T> DList<T> {
}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Drop for DList<T> {
fn drop(&mut self) {
// Dissolve the dlist in backwards direction
@ -642,7 +642,7 @@ impl<T> Drop for DList<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> Iterator for Iter<'a, A> {
type Item = &'a A;
@ -664,7 +664,7 @@ impl<'a, A> Iterator for Iter<'a, A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
#[inline]
fn next_back(&mut self) -> Option<&'a A> {
@ -679,10 +679,10 @@ impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> ExactSizeIterator for Iter<'a, A> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> Iterator for IterMut<'a, A> {
type Item = &'a mut A;
#[inline]
@ -706,7 +706,7 @@ impl<'a, A> Iterator for IterMut<'a, A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
#[inline]
fn next_back(&mut self) -> Option<&'a mut A> {
@ -721,7 +721,7 @@ impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> ExactSizeIterator for IterMut<'a, A> {}
// private methods for IterMut
@ -770,7 +770,8 @@ impl<'a, A> IterMut<'a, A> {
/// }
/// ```
#[inline]
#[unstable = "this is probably better handled by a cursor type -- we'll see"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this is probably better handled by a cursor type -- we'll see")]
pub fn insert_next(&mut self, elt: A) {
self.insert_next_node(box Node::new(elt))
}
@ -791,7 +792,8 @@ impl<'a, A> IterMut<'a, A> {
/// assert_eq!(it.next().unwrap(), &2);
/// ```
#[inline]
#[unstable = "this is probably better handled by a cursor type -- we'll see"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this is probably better handled by a cursor type -- we'll see")]
pub fn peek_next(&mut self) -> Option<&mut A> {
if self.nelem == 0 {
return None
@ -800,7 +802,7 @@ impl<'a, A> IterMut<'a, A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> Iterator for IntoIter<A> {
type Item = A;
@ -813,13 +815,13 @@ impl<A> Iterator for IntoIter<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> DoubleEndedIterator for IntoIter<A> {
#[inline]
fn next_back(&mut self) -> Option<A> { self.list.pop_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> FromIterator<A> for DList<A> {
fn from_iter<T: Iterator<Item=A>>(iterator: T) -> DList<A> {
let mut ret = DList::new();
@ -828,14 +830,14 @@ impl<A> FromIterator<A> for DList<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> Extend<A> for DList<A> {
fn extend<T: Iterator<Item=A>>(&mut self, mut iterator: T) {
for elt in iterator { self.push_back(elt); }
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: PartialEq> PartialEq for DList<A> {
fn eq(&self, other: &DList<A>) -> bool {
self.len() == other.len() &&
@ -848,17 +850,17 @@ impl<A: PartialEq> PartialEq for DList<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: Eq> Eq for DList<A> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: PartialOrd> PartialOrd for DList<A> {
fn partial_cmp(&self, other: &DList<A>) -> Option<Ordering> {
iter::order::partial_cmp(self.iter(), other.iter())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: Ord> Ord for DList<A> {
#[inline]
fn cmp(&self, other: &DList<A>) -> Ordering {
@ -866,14 +868,14 @@ impl<A: Ord> Ord for DList<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: Clone> Clone for DList<A> {
fn clone(&self) -> DList<A> {
self.iter().map(|x| x.clone()).collect()
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: fmt::Show> fmt::Show for DList<A> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "DList ["));
@ -887,7 +889,7 @@ impl<A: fmt::Show> fmt::Show for DList<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<S: Writer + Hasher, A: Hash<S>> Hash<S> for DList<A> {
fn hash(&self, state: &mut S) {
self.len().hash(state);

30
src/libcollections/enum_set.rs
View File

@ -82,19 +82,22 @@ fn bit<E:CLike>(e: &E) -> uint {
impl<E:CLike> EnumSet<E> {
/// Returns an empty `EnumSet`.
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn new() -> EnumSet<E> {
EnumSet {bits: 0}
}
/// Returns the number of elements in the given `EnumSet`.
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn len(&self) -> uint {
self.bits.count_ones()
}
/// Returns true if the `EnumSet` is empty.
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn is_empty(&self) -> bool {
self.bits == 0
}
@ -104,19 +107,22 @@ impl<E:CLike> EnumSet<E> {
}
/// Returns `false` if the `EnumSet` contains any enum of the given `EnumSet`.
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn is_disjoint(&self, other: &EnumSet<E>) -> bool {
(self.bits & other.bits) == 0
}
/// Returns `true` if a given `EnumSet` is included in this `EnumSet`.
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn is_superset(&self, other: &EnumSet<E>) -> bool {
(self.bits & other.bits) == other.bits
}
/// Returns `true` if this `EnumSet` is included in the given `EnumSet`.
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn is_subset(&self, other: &EnumSet<E>) -> bool {
other.is_superset(self)
}
@ -132,7 +138,8 @@ impl<E:CLike> EnumSet<E> {
}
/// Adds an enum to the `EnumSet`, and returns `true` if it wasn't there before
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn insert(&mut self, e: E) -> bool {
let result = !self.contains(&e);
self.bits |= bit(&e);
@ -140,7 +147,8 @@ impl<E:CLike> EnumSet<E> {
}
/// Removes an enum from the EnumSet
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn remove(&mut self, e: &E) -> bool {
let result = self.contains(e);
self.bits &= !bit(e);
@ -148,13 +156,15 @@ impl<E:CLike> EnumSet<E> {
}
/// Returns `true` if an `EnumSet` contains a given enum.
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn contains(&self, e: &E) -> bool {
(self.bits & bit(e)) != 0
}
/// Returns an iterator over an `EnumSet`.
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn iter(&self) -> Iter<E> {
Iter::new(self.bits)
}

12
src/libcollections/lib.rs
View File

@ -14,7 +14,7 @@
#![crate_name = "collections"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "rlib"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@ -70,23 +70,25 @@ pub mod string;
pub mod vec;
pub mod vec_map;
#[unstable = "RFC 509"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "RFC 509")]
pub mod bitv {
pub use bit::{Bitv, Iter};
}
#[unstable = "RFC 509"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "RFC 509")]
pub mod bitv_set {
pub use bit::{BitvSet, Union, Intersection, Difference, SymmetricDifference};
pub use bit::SetIter as Iter;
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub mod btree_map {
pub use btree::map::*;
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub mod btree_set {
pub use btree::set::*;
}

2
src/libcollections/macros.rs
View File

@ -10,7 +10,7 @@
/// Creates a `Vec` containing the arguments.
#[macro_export]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
macro_rules! vec {
($x:expr; $y:expr) => ({
let xs: $crate::boxed::Box<[_]> = $crate::boxed::Box::new([$x; $y]);

138
src/libcollections/ring_buf.rs
View File

@ -12,7 +12,7 @@
//! ends of the container. It also has `O(1)` indexing like a vector. The contained elements are
//! not required to be copyable, and the queue will be sendable if the contained type is sendable.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use core::prelude::*;
@ -36,7 +36,7 @@ static INITIAL_CAPACITY: uint = 7u; // 2^3 - 1
static MINIMUM_CAPACITY: uint = 1u; // 2 - 1
/// `RingBuf` is a circular buffer, which can be used as a double-ended queue efficiently.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct RingBuf<T> {
// tail and head are pointers into the buffer. Tail always points
// to the first element that could be read, Head always points
@ -50,13 +50,13 @@ pub struct RingBuf<T> {
ptr: *mut T
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe impl<T: Send> Send for RingBuf<T> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe impl<T: Sync> Sync for RingBuf<T> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Clone> Clone for RingBuf<T> {
fn clone(&self) -> RingBuf<T> {
self.iter().map(|t| t.clone()).collect()
@ -64,7 +64,7 @@ impl<T: Clone> Clone for RingBuf<T> {
}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Drop for RingBuf<T> {
fn drop(&mut self) {
self.clear();
@ -78,7 +78,7 @@ impl<T> Drop for RingBuf<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Default for RingBuf<T> {
#[inline]
fn default() -> RingBuf<T> { RingBuf::new() }
@ -146,13 +146,13 @@ impl<T> RingBuf<T> {
impl<T> RingBuf<T> {
/// Creates an empty `RingBuf`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> RingBuf<T> {
RingBuf::with_capacity(INITIAL_CAPACITY)
}
/// Creates an empty `RingBuf` with space for at least `n` elements.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn with_capacity(n: uint) -> RingBuf<T> {
// +1 since the ringbuffer always leaves one space empty
let cap = cmp::max(n + 1, MINIMUM_CAPACITY + 1).next_power_of_two();
@ -191,7 +191,7 @@ impl<T> RingBuf<T> {
/// buf.push_back(5);
/// assert_eq!(buf.get(1).unwrap(), &4);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn get(&self, i: uint) -> Option<&T> {
if i < self.len() {
let idx = self.wrap_index(self.tail + i);
@ -221,7 +221,7 @@ impl<T> RingBuf<T> {
///
/// assert_eq!(buf[1], 7);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn get_mut(&mut self, i: uint) -> Option<&mut T> {
if i < self.len() {
let idx = self.wrap_index(self.tail + i);
@ -250,7 +250,7 @@ impl<T> RingBuf<T> {
/// assert_eq!(buf[0], 5);
/// assert_eq!(buf[2], 3);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn swap(&mut self, i: uint, j: uint) {
assert!(i < self.len());
assert!(j < self.len());
@ -273,7 +273,7 @@ impl<T> RingBuf<T> {
/// assert!(buf.capacity() >= 10);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn capacity(&self) -> uint { self.cap - 1 }
/// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
@ -296,7 +296,7 @@ impl<T> RingBuf<T> {
/// buf.reserve_exact(10);
/// assert!(buf.capacity() >= 11);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve_exact(&mut self, additional: uint) {
self.reserve(additional);
}
@ -317,7 +317,7 @@ impl<T> RingBuf<T> {
/// buf.reserve(10);
/// assert!(buf.capacity() >= 11);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve(&mut self, additional: uint) {
let new_len = self.len() + additional;
assert!(new_len + 1 > self.len(), "capacity overflow");
@ -480,7 +480,8 @@ impl<T> RingBuf<T> {
/// assert_eq!(buf.len(), 1);
/// assert_eq!(Some(&5), buf.get(0));
/// ```
#[unstable = "matches collection reform specification; waiting on panic semantics"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification; waiting on panic semantics")]
pub fn truncate(&mut self, len: uint) {
for _ in range(len, self.len()) {
self.pop_back();
@ -501,7 +502,7 @@ impl<T> RingBuf<T> {
/// let b: &[_] = &[&5, &3, &4];
/// assert_eq!(buf.iter().collect::<Vec<&int>>().as_slice(), b);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
Iter {
tail: self.tail,
@ -527,7 +528,7 @@ impl<T> RingBuf<T> {
/// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
/// assert_eq!(&buf.iter_mut().collect::<Vec<&mut int>>()[], b);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
IterMut {
tail: self.tail,
@ -539,7 +540,7 @@ impl<T> RingBuf<T> {
}
/// Consumes the list into an iterator yielding elements by value.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<T> {
IntoIter {
inner: self,
@ -549,7 +550,8 @@ impl<T> RingBuf<T> {
/// Returns a pair of slices which contain, in order, the contents of the
/// `RingBuf`.
#[inline]
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) {
unsafe {
let contiguous = self.is_contiguous();
@ -568,7 +570,8 @@ impl<T> RingBuf<T> {
/// Returns a pair of slices which contain, in order, the contents of the
/// `RingBuf`.
#[inline]
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) {
unsafe {
let contiguous = self.is_contiguous();
@ -600,7 +603,7 @@ impl<T> RingBuf<T> {
/// v.push_back(1i);
/// assert_eq!(v.len(), 1);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint { count(self.tail, self.head, self.cap) }
/// Returns true if the buffer contains no elements
@ -615,7 +618,7 @@ impl<T> RingBuf<T> {
/// v.push_front(1i);
/// assert!(!v.is_empty());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool { self.len() == 0 }
/// Creates a draining iterator that clears the `RingBuf` and iterates over
@ -632,7 +635,8 @@ impl<T> RingBuf<T> {
/// assert!(v.is_empty());
/// ```
#[inline]
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain(&mut self) -> Drain<T> {
Drain {
inner: self,
@ -651,7 +655,7 @@ impl<T> RingBuf<T> {
/// v.clear();
/// assert!(v.is_empty());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
pub fn clear(&mut self) {
self.drain();
@ -672,7 +676,7 @@ impl<T> RingBuf<T> {
/// d.push_back(2i);
/// assert_eq!(d.front(), Some(&1i));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn front(&self) -> Option<&T> {
if !self.is_empty() { Some(&self[0]) } else { None }
}
@ -696,7 +700,7 @@ impl<T> RingBuf<T> {
/// }
/// assert_eq!(d.front(), Some(&9i));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn front_mut(&mut self) -> Option<&mut T> {
if !self.is_empty() { Some(&mut self[0]) } else { None }
}
@ -716,7 +720,7 @@ impl<T> RingBuf<T> {
/// d.push_back(2i);
/// assert_eq!(d.back(), Some(&2i));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn back(&self) -> Option<&T> {
if !self.is_empty() { Some(&self[self.len() - 1]) } else { None }
}
@ -740,7 +744,7 @@ impl<T> RingBuf<T> {
/// }
/// assert_eq!(d.back(), Some(&9i));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn back_mut(&mut self) -> Option<&mut T> {
let len = self.len();
if !self.is_empty() { Some(&mut self[len - 1]) } else { None }
@ -762,7 +766,7 @@ impl<T> RingBuf<T> {
/// assert_eq!(d.pop_front(), Some(2i));
/// assert_eq!(d.pop_front(), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn pop_front(&mut self) -> Option<T> {
if self.is_empty() {
None
@ -785,7 +789,7 @@ impl<T> RingBuf<T> {
/// d.push_front(2i);
/// assert_eq!(d.front(), Some(&2i));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn push_front(&mut self, t: T) {
if self.is_full() {
self.reserve(1);
@ -809,7 +813,7 @@ impl<T> RingBuf<T> {
/// buf.push_back(3);
/// assert_eq!(3, *buf.back().unwrap());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn push_back(&mut self, t: T) {
if self.is_full() {
self.reserve(1);
@ -835,7 +839,7 @@ impl<T> RingBuf<T> {
/// buf.push_back(3);
/// assert_eq!(buf.pop_back(), Some(3));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn pop_back(&mut self) -> Option<T> {
if self.is_empty() {
None
@ -872,7 +876,8 @@ impl<T> RingBuf<T> {
/// buf.push_back(10);
/// assert_eq!(buf.swap_back_remove(1), Some(99));
/// ```
#[unstable = "the naming of this function may be altered"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "the naming of this function may be altered")]
pub fn swap_back_remove(&mut self, index: uint) -> Option<T> {
let length = self.len();
if length > 0 && index < length - 1 {
@ -904,7 +909,8 @@ impl<T> RingBuf<T> {
/// buf.push_back(20i);
/// assert_eq!(buf.swap_front_remove(3), Some(99));
/// ```
#[unstable = "the naming of this function may be altered"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "the naming of this function may be altered")]
pub fn swap_front_remove(&mut self, index: uint) -> Option<T> {
let length = self.len();
if length > 0 && index < length && index != 0 {
@ -1137,7 +1143,7 @@ impl<T> RingBuf<T> {
/// buf.remove(2);
/// assert_eq!(Some(&15), buf.get(2));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn remove(&mut self, i: uint) -> Option<T> {
if self.is_empty() || self.len() <= i {
return None;
@ -1304,7 +1310,8 @@ impl<T: Clone> RingBuf<T> {
/// assert_eq!(a, b);
/// }
/// ```
#[unstable = "matches collection reform specification; waiting on panic semantics"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification; waiting on panic semantics")]
pub fn resize(&mut self, new_len: uint, value: T) {
let len = self.len();
@ -1331,7 +1338,7 @@ fn count(tail: uint, head: uint, size: uint) -> uint {
}
/// `RingBuf` iterator.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Iter<'a, T:'a> {
ring: &'a [T],
tail: uint,
@ -1349,7 +1356,7 @@ impl<'a, T> Clone for Iter<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
@ -1370,7 +1377,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a T> {
@ -1382,10 +1389,10 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> RandomAccessIterator for Iter<'a, T> {
#[inline]
fn indexable(&self) -> uint {
@ -1408,7 +1415,7 @@ impl<'a, T> RandomAccessIterator for Iter<'a, T> {
// with returning the mutable reference. I couldn't find a way to
// make the lifetime checker happy so, but there should be a way.
/// `RingBuf` mutable iterator.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IterMut<'a, T:'a> {
ptr: *mut T,
tail: uint,
@ -1417,7 +1424,7 @@ pub struct IterMut<'a, T:'a> {
marker: marker::ContravariantLifetime<'a>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
@ -1441,7 +1448,7 @@ impl<'a, T> Iterator for IterMut<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a mut T> {
@ -1456,16 +1463,16 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
/// A by-value RingBuf iterator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IntoIter<T> {
inner: RingBuf<T>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Iterator for IntoIter<T> {
type Item = T;
@ -1481,7 +1488,7 @@ impl<T> Iterator for IntoIter<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
#[inline]
fn next_back(&mut self) -> Option<T> {
@ -1489,17 +1496,18 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> ExactSizeIterator for IntoIter<T> {}
/// A draining RingBuf iterator
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub struct Drain<'a, T: 'a> {
inner: &'a mut RingBuf<T>,
}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: 'a> Drop for Drain<'a, T> {
fn drop(&mut self) {
for _ in *self {}
@ -1508,7 +1516,7 @@ impl<'a, T: 'a> Drop for Drain<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: 'a> Iterator for Drain<'a, T> {
type Item = T;
@ -1524,7 +1532,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<T> {
@ -1532,10 +1540,10 @@ impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: PartialEq> PartialEq for RingBuf<A> {
fn eq(&self, other: &RingBuf<A>) -> bool {
self.len() == other.len() &&
@ -1543,17 +1551,17 @@ impl<A: PartialEq> PartialEq for RingBuf<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: Eq> Eq for RingBuf<A> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: PartialOrd> PartialOrd for RingBuf<A> {
fn partial_cmp(&self, other: &RingBuf<A>) -> Option<Ordering> {
iter::order::partial_cmp(self.iter(), other.iter())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A: Ord> Ord for RingBuf<A> {
#[inline]
fn cmp(&self, other: &RingBuf<A>) -> Ordering {
@ -1561,7 +1569,7 @@ impl<A: Ord> Ord for RingBuf<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<S: Writer + Hasher, A: Hash<S>> Hash<S> for RingBuf<A> {
fn hash(&self, state: &mut S) {
self.len().hash(state);
@ -1571,7 +1579,7 @@ impl<S: Writer + Hasher, A: Hash<S>> Hash<S> for RingBuf<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> Index<uint> for RingBuf<A> {
type Output = A;
@ -1581,7 +1589,7 @@ impl<A> Index<uint> for RingBuf<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> IndexMut<uint> for RingBuf<A> {
type Output = A;
@ -1591,7 +1599,7 @@ impl<A> IndexMut<uint> for RingBuf<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> FromIterator<A> for RingBuf<A> {
fn from_iter<T: Iterator<Item=A>>(iterator: T) -> RingBuf<A> {
let (lower, _) = iterator.size_hint();
@ -1601,7 +1609,7 @@ impl<A> FromIterator<A> for RingBuf<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> Extend<A> for RingBuf<A> {
fn extend<T: Iterator<Item=A>>(&mut self, mut iterator: T) {
for elt in iterator {
@ -1610,7 +1618,7 @@ impl<A> Extend<A> for RingBuf<A> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: fmt::Show> fmt::Show for RingBuf<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "RingBuf ["));

151
src/libcollections/slice.rs
View File

@ -86,7 +86,7 @@
//! * Further iterators exist that split, chunk or permute the slice.
#![doc(primitive = "slice")]
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use alloc::boxed::Box;
use core::borrow::{BorrowFrom, BorrowFromMut, ToOwned};
@ -120,9 +120,9 @@ pub use core::slice::{from_raw_buf, from_raw_mut_buf};
////////////////////////////////////////////////////////////////////////////////
/// Allocating extension methods for slices.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait SliceExt {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Item;
/// Sorts the slice, in place, using `compare` to compare
@ -142,7 +142,7 @@ pub trait SliceExt {
/// v.sort_by(|a, b| b.cmp(a));
/// assert!(v == [5, 4, 3, 2, 1]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn sort_by<F>(&mut self, compare: F) where F: FnMut(&Self::Item, &Self::Item) -> Ordering;
/// Consumes `src` and moves as many elements as it can into `self`
@ -166,7 +166,8 @@ pub trait SliceExt {
/// assert_eq!(num_moved, 3);
/// assert!(a == [6i, 7, 8, 4, 5]);
/// ```
#[unstable = "uncertain about this API approach"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "uncertain about this API approach")]
fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint;
/// Returns a subslice spanning the interval [`start`, `end`).
@ -175,7 +176,8 @@ pub trait SliceExt {
/// original slice (i.e. when `end > self.len()`) or when `start > end`.
///
/// Slicing with `start` equal to `end` yields an empty slice.
#[unstable = "will be replaced by slice syntax"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will be replaced by slice syntax")]
fn slice(&self, start: uint, end: uint) -> &[Self::Item];
/// Returns a subslice from `start` to the end of the slice.
@ -183,7 +185,8 @@ pub trait SliceExt {
/// Panics when `start` is strictly greater than the length of the original slice.
///
/// Slicing from `self.len()` yields an empty slice.
#[unstable = "will be replaced by slice syntax"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will be replaced by slice syntax")]
fn slice_from(&self, start: uint) -> &[Self::Item];
/// Returns a subslice from the start of the slice to `end`.
@ -191,7 +194,8 @@ pub trait SliceExt {
/// Panics when `end` is strictly greater than the length of the original slice.
///
/// Slicing to `0` yields an empty slice.
#[unstable = "will be replaced by slice syntax"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will be replaced by slice syntax")]
fn slice_to(&self, end: uint) -> &[Self::Item];
/// Divides one slice into two at an index.
@ -201,23 +205,23 @@ pub trait SliceExt {
/// indices from `[mid, len)` (excluding the index `len` itself).
///
/// Panics if `mid > len`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn split_at(&self, mid: uint) -> (&[Self::Item], &[Self::Item]);
/// Returns an iterator over the slice
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn iter(&self) -> Iter<Self::Item>;
/// Returns an iterator over subslices separated by elements that match
/// `pred`. The matched element is not contained in the subslices.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn split<F>(&self, pred: F) -> Split<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over subslices separated by elements that match
/// `pred`, limited to splitting at most `n` times. The matched element is
/// not contained in the subslices.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn splitn<F>(&self, n: uint, pred: F) -> SplitN<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
@ -225,7 +229,7 @@ pub trait SliceExt {
/// `pred` limited to splitting at most `n` times. This starts at the end of
/// the slice and works backwards. The matched element is not contained in
/// the subslices.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn rsplitn<F>(&self, n: uint, pred: F) -> RSplitN<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
@ -248,7 +252,7 @@ pub trait SliceExt {
/// println!("{:?}", win);
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn windows(&self, size: uint) -> Windows<Self::Item>;
/// Returns an iterator over `size` elements of the slice at a
@ -271,33 +275,33 @@ pub trait SliceExt {
/// println!("{:?}", win);
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn chunks(&self, size: uint) -> Chunks<Self::Item>;
/// Returns the element of a slice at the given index, or `None` if the
/// index is out of bounds.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn get(&self, index: uint) -> Option<&Self::Item>;
/// Returns the first element of a slice, or `None` if it is empty.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn first(&self) -> Option<&Self::Item>;
/// Returns all but the first element of a slice.
#[unstable = "likely to be renamed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be renamed")]
fn tail(&self) -> &[Self::Item];
/// Returns all but the last element of a slice.
#[unstable = "likely to be renamed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be renamed")]
fn init(&self) -> &[Self::Item];
/// Returns the last element of a slice, or `None` if it is empty.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn last(&self) -> Option<&Self::Item>;
/// Returns a pointer to the element at the given index, without doing
/// bounds checking.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn get_unchecked(&self, index: uint) -> &Self::Item;
/// Returns an unsafe pointer to the slice's buffer
@ -307,7 +311,7 @@ pub trait SliceExt {
///
/// Modifying the slice may cause its buffer to be reallocated, which
/// would also make any pointers to it invalid.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn as_ptr(&self) -> *const Self::Item;
/// Binary search a sorted slice with a comparator function.
@ -342,7 +346,7 @@ pub trait SliceExt {
/// let r = s.binary_search_by(|probe| probe.cmp(&seek));
/// assert!(match r { Ok(1...4) => true, _ => false, });
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn binary_search_by<F>(&self, f: F) -> Result<uint, uint> where
F: FnMut(&Self::Item) -> Ordering;
@ -354,7 +358,7 @@ pub trait SliceExt {
/// let a = [1i, 2, 3];
/// assert_eq!(a.len(), 3);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn len(&self) -> uint;
/// Returns true if the slice has a length of 0
@ -366,16 +370,16 @@ pub trait SliceExt {
/// assert!(!a.is_empty());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn is_empty(&self) -> bool { self.len() == 0 }
/// Returns a mutable reference to the element at the given index,
/// or `None` if the index is out of bounds
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn get_mut(&mut self, index: uint) -> Option<&mut Self::Item>;
/// Work with `self` as a mut slice.
/// Primarily intended for getting a &mut [T] from a [T; N].
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn as_mut_slice(&mut self) -> &mut [Self::Item];
/// Returns a mutable subslice spanning the interval [`start`, `end`).
@ -384,7 +388,8 @@ pub trait SliceExt {
/// original slice (i.e. when `end > self.len()`) or when `start > end`.
///
/// Slicing with `start` equal to `end` yields an empty slice.
#[unstable = "will be replaced by slice syntax"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will be replaced by slice syntax")]
fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item];
/// Returns a mutable subslice from `start` to the end of the slice.
@ -392,7 +397,8 @@ pub trait SliceExt {
/// Panics when `start` is strictly greater than the length of the original slice.
///
/// Slicing from `self.len()` yields an empty slice.
#[unstable = "will be replaced by slice syntax"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will be replaced by slice syntax")]
fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item];
/// Returns a mutable subslice from the start of the slice to `end`.
@ -400,39 +406,42 @@ pub trait SliceExt {
/// Panics when `end` is strictly greater than the length of the original slice.
///
/// Slicing to `0` yields an empty slice.
#[unstable = "will be replaced by slice syntax"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will be replaced by slice syntax")]
fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item];
/// Returns an iterator that allows modifying each value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn iter_mut(&mut self) -> IterMut<Self::Item>;
/// Returns a mutable pointer to the first element of a slice, or `None` if it is empty
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn first_mut(&mut self) -> Option<&mut Self::Item>;
/// Returns all but the first element of a mutable slice
#[unstable = "likely to be renamed or removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to be renamed or removed")]
fn tail_mut(&mut self) -> &mut [Self::Item];
/// Returns all but the last element of a mutable slice
#[unstable = "likely to be renamed or removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to be renamed or removed")]
fn init_mut(&mut self) -> &mut [Self::Item];
/// Returns a mutable pointer to the last item in the slice.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn last_mut(&mut self) -> Option<&mut Self::Item>;
/// Returns an iterator over mutable subslices separated by elements that
/// match `pred`. The matched element is not contained in the subslices.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn split_mut<F>(&mut self, pred: F) -> SplitMut<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
/// Returns an iterator over subslices separated by elements that match
/// `pred`, limited to splitting at most `n` times. The matched element is
/// not contained in the subslices.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn splitn_mut<F>(&mut self, n: uint, pred: F) -> SplitNMut<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
@ -440,7 +449,7 @@ pub trait SliceExt {
/// `pred` limited to splitting at most `n` times. This starts at the end of
/// the slice and works backwards. The matched element is not contained in
/// the subslices.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn rsplitn_mut<F>(&mut self, n: uint, pred: F) -> RSplitNMut<Self::Item, F>
where F: FnMut(&Self::Item) -> bool;
@ -452,7 +461,7 @@ pub trait SliceExt {
/// # Panics
///
/// Panics if `chunk_size` is 0.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn chunks_mut(&mut self, chunk_size: uint) -> ChunksMut<Self::Item>;
/// Swaps two elements in a slice.
@ -473,7 +482,7 @@ pub trait SliceExt {
/// v.swap(1, 3);
/// assert!(v == ["a", "d", "c", "b"]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn swap(&mut self, a: uint, b: uint);
/// Divides one `&mut` into two at an index.
@ -510,7 +519,7 @@ pub trait SliceExt {
/// assert!(right == []);
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn split_at_mut(&mut self, mid: uint) -> (&mut [Self::Item], &mut [Self::Item]);
/// Reverse the order of elements in a slice, in place.
@ -522,11 +531,11 @@ pub trait SliceExt {
/// v.reverse();
/// assert!(v == [3i, 2, 1]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn reverse(&mut self);
/// Returns an unsafe mutable pointer to the element in index
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn get_unchecked_mut(&mut self, index: uint) -> &mut Self::Item;
/// Return an unsafe mutable pointer to the slice's buffer.
@ -537,11 +546,11 @@ pub trait SliceExt {
/// Modifying the slice may cause its buffer to be reallocated, which
/// would also make any pointers to it invalid.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn as_mut_ptr(&mut self) -> *mut Self::Item;
/// Copies `self` into a new `Vec`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn to_vec(&self) -> Vec<Self::Item> where Self::Item: Clone;
/// Creates an iterator that yields every possible permutation of the
@ -568,7 +577,7 @@ pub trait SliceExt {
/// assert_eq!(Some(vec![1i, 3, 2]), perms.next());
/// assert_eq!(Some(vec![3i, 1, 2]), perms.next());
/// ```
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
fn permutations(&self) -> Permutations<Self::Item> where Self::Item: Clone;
/// Copies as many elements from `src` as it can into `self` (the
@ -588,7 +597,7 @@ pub trait SliceExt {
/// assert!(dst.clone_from_slice(&src2) == 3);
/// assert!(dst == [3i, 4, 5]);
/// ```
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
/// Sorts the slice, in place.
@ -603,7 +612,7 @@ pub trait SliceExt {
/// v.sort();
/// assert!(v == [-5i, -3, 1, 2, 4]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn sort(&mut self) where Self::Item: Ord;
/// Binary search a sorted slice for a given element.
@ -629,11 +638,11 @@ pub trait SliceExt {
/// let r = s.binary_search(&1);
/// assert!(match r { Ok(1...4) => true, _ => false, });
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn binary_search(&self, x: &Self::Item) -> Result<uint, uint> where Self::Item: Ord;
/// Deprecated: use `binary_search` instead.
#[deprecated = "use binary_search instead"]
#[deprecated(feature = "oldstuff", since = "1.0.0", reason = "use binary_search instead")]
fn binary_search_elem(&self, x: &Self::Item) -> Result<uint, uint> where Self::Item: Ord {
self.binary_search(x)
}
@ -654,7 +663,8 @@ pub trait SliceExt {
/// let b: &mut [_] = &mut [1i, 0, 2];
/// assert!(v == b);
/// ```
#[unstable = "uncertain if this merits inclusion in std"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "uncertain if this merits inclusion in std")]
fn next_permutation(&mut self) -> bool where Self::Item: Ord;
/// Mutates the slice to the previous lexicographic permutation.
@ -673,35 +683,36 @@ pub trait SliceExt {
/// let b: &mut [_] = &mut [0i, 1, 2];
/// assert!(v == b);
/// ```
#[unstable = "uncertain if this merits inclusion in std"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "uncertain if this merits inclusion in std")]
fn prev_permutation(&mut self) -> bool where Self::Item: Ord;
/// Find the first index containing a matching value.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
/// Find the last index containing a matching value.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
fn rposition_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
/// Return true if the slice contains an element with the given value.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn contains(&self, x: &Self::Item) -> bool where Self::Item: PartialEq;
/// Returns true if `needle` is a prefix of the slice.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn starts_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq;
/// Returns true if `needle` is a suffix of the slice.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn ends_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq;
/// Convert `self` into a vector without clones or allocation.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
fn into_vec(self: Box<Self>) -> Vec<Self::Item>;
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> SliceExt for [T] {
type Item = T;
@ -989,16 +1000,16 @@ impl<T> SliceExt for [T] {
////////////////////////////////////////////////////////////////////////////////
// Extension traits for slices over specific kinds of data
////////////////////////////////////////////////////////////////////////////////
#[unstable = "U should be an associated type"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "U should be an associated type")]
/// An extension trait for concatenating slices
pub trait SliceConcatExt<T: ?Sized, U> {
/// Flattens a slice of `T` into a single value `U`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn concat(&self) -> U;
/// Flattens a slice of `T` into a single value `U`, placing a
/// given separator between each.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn connect(&self, sep: &T) -> U;
}
@ -1034,7 +1045,7 @@ impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] {
///
/// The last generated swap is always (0, 1), and it returns the
/// sequence to its initial order.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[derive(Clone)]
pub struct ElementSwaps {
sdir: Vec<SizeDirection>,
@ -1046,7 +1057,7 @@ pub struct ElementSwaps {
impl ElementSwaps {
/// Creates an `ElementSwaps` iterator for a sequence of `length` elements.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn new(length: uint) -> ElementSwaps {
// Initialize `sdir` with a direction that position should move in
// (all negative at the beginning) and the `size` of the
@ -1063,17 +1074,17 @@ impl ElementSwaps {
// Standard trait implementations for slices
////////////////////////////////////////////////////////////////////////////////
#[unstable = "trait is unstable"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")]
impl<T> BorrowFrom<Vec<T>> for [T] {
fn borrow_from(owned: &Vec<T>) -> &[T] { &owned[] }
}
#[unstable = "trait is unstable"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")]
impl<T> BorrowFromMut<Vec<T>> for [T] {
fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { &mut owned[] }
}
#[unstable = "trait is unstable"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")]
impl<T: Clone> ToOwned<Vec<T>> for [T] {
fn to_owned(&self) -> Vec<T> { self.to_vec() }
}
@ -1092,7 +1103,7 @@ struct SizeDirection {
dir: Direction,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Iterator for ElementSwaps {
type Item = (uint, uint);
@ -1155,13 +1166,13 @@ impl Iterator for ElementSwaps {
/// swap applied.
///
/// Generates even and odd permutations alternately.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub struct Permutations<T> {
swaps: ElementSwaps,
v: Vec<T>,
}
#[unstable = "trait is unstable"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")]
impl<T: Clone> Iterator for Permutations<T> {
type Item = Vec<T>;

154
src/libcollections/str.rs
View File

@ -50,7 +50,7 @@
//! is the same as `&[u8]`.
#![doc(primitive = "str")]
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use self::RecompositionState::*;
use self::DecompositionType::*;
@ -165,7 +165,7 @@ enum DecompositionType {
/// External iterator for a string's decomposition's characters.
/// Use with the `std::iter` module.
#[derive(Clone)]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub struct Decompositions<'a> {
kind: DecompositionType,
iter: Chars<'a>,
@ -173,7 +173,7 @@ pub struct Decompositions<'a> {
sorted: bool
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for Decompositions<'a> {
type Item = char;
@ -255,7 +255,7 @@ enum RecompositionState {
/// External iterator for a string's recomposition's characters.
/// Use with the `std::iter` module.
#[derive(Clone)]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub struct Recompositions<'a> {
iter: Decompositions<'a>,
state: RecompositionState,
@ -264,7 +264,7 @@ pub struct Recompositions<'a> {
last_ccc: Option<u8>
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for Recompositions<'a> {
type Item = char;
@ -352,12 +352,12 @@ impl<'a> Iterator for Recompositions<'a> {
/// External iterator for a string's UTF16 codeunits.
/// Use with the `std::iter` module.
#[derive(Clone)]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub struct Utf16Units<'a> {
encoder: Utf16Encoder<Chars<'a>>
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for Utf16Units<'a> {
type Item = u16;
@ -384,12 +384,12 @@ macro_rules! utf8_acc_cont_byte {
($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as u32)
}
#[unstable = "trait is unstable"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")]
impl BorrowFrom<String> for str {
fn borrow_from(owned: &String) -> &str { &owned[] }
}
#[unstable = "trait is unstable"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")]
impl ToOwned<String> for str {
fn to_owned(&self) -> String {
unsafe {
@ -407,16 +407,18 @@ Section: Trait implementations
*/
/// Any string that can be represented as a slice.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait StrExt: Index<FullRange, Output = str> {
/// Escapes each char in `s` with `char::escape_default`.
#[unstable = "return type may change to be an iterator"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "return type may change to be an iterator")]
fn escape_default(&self) -> String {
self.chars().flat_map(|c| c.escape_default()).collect()
}
/// Escapes each char in `s` with `char::escape_unicode`.
#[unstable = "return type may change to be an iterator"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "return type may change to be an iterator")]
fn escape_unicode(&self) -> String {
self.chars().flat_map(|c| c.escape_unicode()).collect()
}
@ -445,7 +447,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// // not found, so no change.
/// assert_eq!(s.replace("cookie monster", "little lamb"), s);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn replace(&self, from: &str, to: &str) -> String {
let mut result = String::new();
let mut last_end = 0;
@ -461,7 +463,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// Returns an iterator over the string in Unicode Normalization Form D
/// (canonical decomposition).
#[inline]
#[unstable = "this functionality may be moved to libunicode"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this functionality may be moved to libunicode")]
fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
Decompositions {
iter: self[].chars(),
@ -474,7 +477,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// Returns an iterator over the string in Unicode Normalization Form KD
/// (compatibility decomposition).
#[inline]
#[unstable = "this functionality may be moved to libunicode"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this functionality may be moved to libunicode")]
fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
Decompositions {
iter: self[].chars(),
@ -487,7 +491,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// An Iterator over the string in Unicode Normalization Form C
/// (canonical decomposition followed by canonical composition).
#[inline]
#[unstable = "this functionality may be moved to libunicode"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this functionality may be moved to libunicode")]
fn nfc_chars<'a>(&'a self) -> Recompositions<'a> {
Recompositions {
iter: self.nfd_chars(),
@ -501,7 +506,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// An Iterator over the string in Unicode Normalization Form KC
/// (compatibility decomposition followed by canonical composition).
#[inline]
#[unstable = "this functionality may be moved to libunicode"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this functionality may be moved to libunicode")]
fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> {
Recompositions {
iter: self.nfkd_chars(),
@ -523,7 +529,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ```rust
/// assert!("bananas".contains("nana"));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn contains(&self, pat: &str) -> bool {
core_str::StrExt::contains(&self[], pat)
}
@ -539,7 +545,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ```rust
/// assert!("hello".contains_char('e'));
/// ```
#[unstable = "might get removed in favour of a more generic contains()"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "might get removed in favour of a more generic contains()")]
fn contains_char<P: CharEq>(&self, pat: P) -> bool {
core_str::StrExt::contains_char(&self[], pat)
}
@ -553,7 +560,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<char> = "abc åäö".chars().collect();
/// assert_eq!(v, vec!['a', 'b', 'c', ' ', 'å', 'ä', 'ö']);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn chars(&self) -> Chars {
core_str::StrExt::chars(&self[])
}
@ -566,13 +573,13 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<u8> = "bors".bytes().collect();
/// assert_eq!(v, b"bors".to_vec());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn bytes(&self) -> Bytes {
core_str::StrExt::bytes(&self[])
}
/// An iterator over the characters of `self` and their byte offsets.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn char_indices(&self) -> CharIndices {
core_str::StrExt::char_indices(&self[])
}
@ -595,7 +602,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = "".split('X').collect();
/// assert_eq!(v, vec![""]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn split<P: CharEq>(&self, pat: P) -> Split<P> {
core_str::StrExt::split(&self[], pat)
}
@ -622,7 +629,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = "".splitn(1, 'X').collect();
/// assert_eq!(v, vec![""]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn splitn<P: CharEq>(&self, count: uint, pat: P) -> SplitN<P> {
core_str::StrExt::splitn(&self[], count, pat)
}
@ -651,7 +658,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = "lionXXtigerXleopard".split('X').rev().collect();
/// assert_eq!(v, vec!["leopard", "tiger", "", "lion"]);
/// ```
#[unstable = "might get removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "might get removed")]
fn split_terminator<P: CharEq>(&self, pat: P) -> SplitTerminator<P> {
core_str::StrExt::split_terminator(&self[], pat)
}
@ -672,7 +679,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(2, 'X').collect();
/// assert_eq!(v, vec!["leopard", "tiger", "lionX"]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn rsplitn<P: CharEq>(&self, count: uint, pat: P) -> RSplitN<P> {
core_str::StrExt::rsplitn(&self[], count, pat)
}
@ -697,7 +704,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect();
/// assert_eq!(v, vec![(0, 3)]); // only the first `aba`
/// ```
#[unstable = "might have its iterator type changed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "might have its iterator type changed")]
fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> {
core_str::StrExt::match_indices(&self[], pat)
}
@ -713,7 +721,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = "1abcabc2".split_str("abc").collect();
/// assert_eq!(v, vec!["1", "", "2"]);
/// ```
#[unstable = "might get removed in the future in favor of a more generic split()"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "might get removed in the future in favor of a more generic split()")]
fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> {
core_str::StrExt::split_str(&self[], pat)
}
@ -729,7 +738,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = four_lines.lines().collect();
/// assert_eq!(v, vec!["foo", "bar", "", "baz"]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn lines(&self) -> Lines {
core_str::StrExt::lines(&self[])
}
@ -745,7 +754,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = four_lines.lines_any().collect();
/// assert_eq!(v, vec!["foo", "bar", "", "baz"]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn lines_any(&self) -> LinesAny {
core_str::StrExt::lines_any(&self[])
}
@ -780,7 +789,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// // byte 100 is outside the string
/// // s.slice(3, 100);
/// ```
#[unstable = "use slice notation [a..b] instead"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "use slice notation [a..b] instead")]
fn slice(&self, begin: uint, end: uint) -> &str {
core_str::StrExt::slice(&self[], begin, end)
}
@ -793,7 +803,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// out of bounds.
///
/// See also `slice`, `slice_to` and `slice_chars`.
#[unstable = "use slice notation [a..] instead"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "use slice notation [a..] instead")]
fn slice_from(&self, begin: uint) -> &str {
core_str::StrExt::slice_from(&self[], begin)
}
@ -807,7 +818,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// out of bounds.
///
/// See also `slice`, `slice_from` and `slice_chars`.
#[unstable = "use slice notation [..a] instead"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "use slice notation [..a] instead")]
fn slice_to(&self, end: uint) -> &str {
core_str::StrExt::slice_to(&self[], end)
}
@ -835,7 +847,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!(s.slice_chars(0, 4), "Löwe");
/// assert_eq!(s.slice_chars(5, 7), "老虎");
/// ```
#[unstable = "may have yet to prove its worth"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "may have yet to prove its worth")]
fn slice_chars(&self, begin: uint, end: uint) -> &str {
core_str::StrExt::slice_chars(&self[], begin, end)
}
@ -846,7 +859,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
///
/// Caller must check both UTF-8 character boundaries and the boundaries of
/// the entire slice as well.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn slice_unchecked(&self, begin: uint, end: uint) -> &str {
core_str::StrExt::slice_unchecked(&self[], begin, end)
}
@ -858,7 +871,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ```rust
/// assert!("banana".starts_with("ba"));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn starts_with(&self, pat: &str) -> bool {
core_str::StrExt::starts_with(&self[], pat)
}
@ -870,7 +883,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ```rust
/// assert!("banana".ends_with("nana"));
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn ends_with(&self, pat: &str) -> bool {
core_str::StrExt::ends_with(&self[], pat)
}
@ -890,7 +903,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");
/// assert_eq!("123foo1bar123".trim_matches(|&: c: char| c.is_numeric()), "foo1bar");
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn trim_matches<P: CharEq>(&self, pat: P) -> &str {
core_str::StrExt::trim_matches(&self[], pat)
}
@ -910,7 +923,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");
/// assert_eq!("123foo1bar123".trim_left_matches(|&: c: char| c.is_numeric()), "foo1bar123");
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn trim_left_matches<P: CharEq>(&self, pat: P) -> &str {
core_str::StrExt::trim_left_matches(&self[], pat)
}
@ -930,7 +943,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");
/// assert_eq!("123foo1bar123".trim_right_matches(|&: c: char| c.is_numeric()), "123foo1bar");
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn trim_right_matches<P: CharEq>(&self, pat: P) -> &str {
core_str::StrExt::trim_right_matches(&self[], pat)
}
@ -958,7 +971,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// // third byte of `老`
/// assert!(!s.is_char_boundary(8));
/// ```
#[unstable = "naming is uncertain with container conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "naming is uncertain with container conventions")]
fn is_char_boundary(&self, index: uint) -> bool {
core_str::StrExt::is_char_boundary(&self[], index)
}
@ -1016,7 +1030,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
///
/// If `i` is greater than or equal to the length of the string.
/// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable = "naming is uncertain with container conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "naming is uncertain with container conventions")]
fn char_range_at(&self, start: uint) -> CharRange {
core_str::StrExt::char_range_at(&self[], start)
}
@ -1031,7 +1046,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
///
/// If `i` is greater than the length of the string.
/// If `i` is not an index following a valid UTF-8 character.
#[unstable = "naming is uncertain with container conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "naming is uncertain with container conventions")]
fn char_range_at_reverse(&self, start: uint) -> CharRange {
core_str::StrExt::char_range_at_reverse(&self[], start)
}
@ -1051,7 +1067,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
///
/// If `i` is greater than or equal to the length of the string.
/// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable = "naming is uncertain with container conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "naming is uncertain with container conventions")]
fn char_at(&self, i: uint) -> char {
core_str::StrExt::char_at(&self[], i)
}
@ -1062,7 +1079,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
///
/// If `i` is greater than the length of the string.
/// If `i` is not an index following a valid UTF-8 character.
#[unstable = "naming is uncertain with container conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "naming is uncertain with container conventions")]
fn char_at_reverse(&self, i: uint) -> char {
core_str::StrExt::char_at_reverse(&self[], i)
}
@ -1074,7 +1092,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// ```rust
/// assert_eq!("bors".as_bytes(), b"bors");
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn as_bytes(&self) -> &[u8] {
core_str::StrExt::as_bytes(&self[])
}
@ -1102,7 +1120,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let x: &[_] = &['1', '2'];
/// assert_eq!(s.find(x), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn find<P: CharEq>(&self, pat: P) -> Option<uint> {
core_str::StrExt::find(&self[], pat)
}
@ -1130,7 +1148,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let x: &[_] = &['1', '2'];
/// assert_eq!(s.rfind(x), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn rfind<P: CharEq>(&self, pat: P) -> Option<uint> {
core_str::StrExt::rfind(&self[], pat)
}
@ -1154,7 +1172,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!(s.find_str("老虎 L"), Some(6));
/// assert_eq!(s.find_str("muffin man"), None);
/// ```
#[unstable = "might get removed in favor of a more generic find in the future"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "might get removed in favor of a more generic find in the future")]
fn find_str(&self, needle: &str) -> Option<uint> {
core_str::StrExt::find_str(&self[], needle)
}
@ -1177,7 +1196,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!(c, 'ö');
/// assert_eq!(s2, "we 老虎 Léopard");
/// ```
#[unstable = "awaiting conventions about shifting and slices"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "awaiting conventions about shifting and slices")]
fn slice_shift_char(&self) -> Option<(char, &str)> {
core_str::StrExt::slice_shift_char(&self[])
}
@ -1196,7 +1216,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert!(string.subslice_offset(lines[1]) == 2); // &"b"
/// assert!(string.subslice_offset(lines[2]) == 4); // &"c"
/// ```
#[unstable = "awaiting convention about comparability of arbitrary slices"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "awaiting convention about comparability of arbitrary slices")]
fn subslice_offset(&self, inner: &str) -> uint {
core_str::StrExt::subslice_offset(&self[], inner)
}
@ -1206,14 +1227,15 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// The caller must ensure that the string outlives this pointer,
/// and that it is not reallocated (e.g. by pushing to the
/// string).
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn as_ptr(&self) -> *const u8 {
core_str::StrExt::as_ptr(&self[])
}
/// Return an iterator of `u16` over the string encoded as UTF-16.
#[unstable = "this functionality may only be provided by libunicode"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this functionality may only be provided by libunicode")]
fn utf16_units(&self) -> Utf16Units {
Utf16Units { encoder: Utf16Encoder::new(self[].chars()) }
}
@ -1226,7 +1248,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!("foo".len(), 3);
/// assert_eq!("ƒoo".len(), 4);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn len(&self) -> uint {
core_str::StrExt::len(&self[])
@ -1240,7 +1262,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert!("".is_empty());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn is_empty(&self) -> bool {
core_str::StrExt::is_empty(&self[])
}
@ -1254,7 +1276,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// assert_eq!("j".parse::<u32>(), None);
/// ```
#[inline]
#[unstable = "this method was just created"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this method was just created")]
fn parse<F: FromStr>(&self) -> Option<F> {
core_str::StrExt::parse(&self[])
}
@ -1278,7 +1301,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"];
/// assert_eq!(gr2.as_slice(), b);
/// ```
#[unstable = "this functionality may only be provided by libunicode"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this functionality may only be provided by libunicode")]
fn graphemes(&self, is_extended: bool) -> Graphemes {
UnicodeStr::graphemes(&self[], is_extended)
}
@ -1293,7 +1317,8 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
/// assert_eq!(gr_inds.as_slice(), b);
/// ```
#[unstable = "this functionality may only be provided by libunicode"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this functionality may only be provided by libunicode")]
fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices {
UnicodeStr::grapheme_indices(&self[], is_extended)
}
@ -1309,7 +1334,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// let v: Vec<&str> = some_words.words().collect();
/// assert_eq!(v, vec!["Mary", "had", "a", "little", "lamb"]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn words(&self) -> Words {
UnicodeStr::words(&self[])
}
@ -1323,31 +1348,32 @@ pub trait StrExt: Index<FullRange, Output = str> {
/// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
/// recommends that these characters be treated as 1 column (i.e.,
/// `is_cjk` = `false`) if the locale is unknown.
#[unstable = "this functionality may only be provided by libunicode"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this functionality may only be provided by libunicode")]
fn width(&self, is_cjk: bool) -> uint {
UnicodeStr::width(&self[], is_cjk)
}
/// Returns a string with leading and trailing whitespace removed.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn trim(&self) -> &str {
UnicodeStr::trim(&self[])
}
/// Returns a string with leading whitespace removed.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn trim_left(&self) -> &str {
UnicodeStr::trim_left(&self[])
}
/// Returns a string with trailing whitespace removed.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn trim_right(&self) -> &str {
UnicodeStr::trim_right(&self[])
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl StrExt for str {}
#[cfg(test)]

112
src/libcollections/string.rs
View File

@ -12,7 +12,7 @@
//! An owned, growable string that enforces that its contents are valid UTF-8.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use core::prelude::*;
@ -33,20 +33,20 @@ use vec::{DerefVec, Vec, as_vec};
/// A growable string stored as a UTF-8 encoded buffer.
#[derive(Clone, PartialOrd, Eq, Ord)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct String {
vec: Vec<u8>,
}
/// A possible error value from the `String::from_utf8` function.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct FromUtf8Error {
bytes: Vec<u8>,
error: Utf8Error,
}
/// A possible error value from the `String::from_utf16` function.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[allow(missing_copy_implementations)]
pub struct FromUtf16Error(());
@ -59,7 +59,7 @@ impl String {
/// let mut s = String::new();
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> String {
String {
vec: Vec::new(),
@ -76,7 +76,7 @@ impl String {
/// let mut s = String::with_capacity(10);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn with_capacity(capacity: uint) -> String {
String {
vec: Vec::with_capacity(capacity),
@ -92,7 +92,8 @@ impl String {
/// assert_eq!(s.as_slice(), "hello");
/// ```
#[inline]
#[unstable = "needs investigation to see if to_string() can match perf"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "needs investigation to see if to_string() can match perf")]
pub fn from_str(string: &str) -> String {
String { vec: ::slice::SliceExt::to_vec(string.as_bytes()) }
}
@ -120,7 +121,7 @@ impl String {
/// assert_eq!(s.into_bytes(), vec![240, 144, 128]);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error> {
match str::from_utf8(vec.as_slice()) {
Ok(..) => Ok(String { vec: vec }),
@ -138,7 +139,7 @@ impl String {
/// let output = String::from_utf8_lossy(input);
/// assert_eq!(output.as_slice(), "Hello \u{FFFD}World");
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> CowString<'a> {
let mut i = 0;
match str::from_utf8(v) {
@ -276,7 +277,7 @@ impl String {
/// v[4] = 0xD800;
/// assert!(String::from_utf16(v).is_err());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error> {
let mut s = String::with_capacity(v.len());
for c in unicode_str::utf16_items(v) {
@ -303,7 +304,7 @@ impl String {
/// "𝄞mus\u{FFFD}ic\u{FFFD}".to_string());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn from_utf16_lossy(v: &[u16]) -> String {
unicode_str::utf16_items(v).map(|c| c.to_char_lossy()).collect()
}
@ -314,7 +315,7 @@ impl String {
/// * We call `Vec::from_raw_parts` to get a `Vec<u8>`;
/// * We assume that the `Vec` contains valid UTF-8.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn from_raw_parts(buf: *mut u8, length: uint, capacity: uint) -> String {
String {
vec: Vec::from_raw_parts(buf, length, capacity),
@ -325,7 +326,7 @@ impl String {
/// it contains valid UTF-8. This is unsafe because it assumes that
/// the UTF-8-ness of the vector has already been validated.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String {
String { vec: bytes }
}
@ -340,7 +341,7 @@ impl String {
/// assert_eq!(bytes, vec![104, 101, 108, 108, 111]);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_bytes(self) -> Vec<u8> {
self.vec
}
@ -355,7 +356,7 @@ impl String {
/// assert_eq!(s.as_slice(), "foobar");
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn push_str(&mut self, string: &str) {
self.vec.push_all(string.as_bytes())
}
@ -370,7 +371,7 @@ impl String {
/// assert!(s.capacity() >= 10);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn capacity(&self) -> uint {
self.vec.capacity()
}
@ -391,7 +392,7 @@ impl String {
/// assert!(s.capacity() >= 10);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve(&mut self, additional: uint) {
self.vec.reserve(additional)
}
@ -416,7 +417,7 @@ impl String {
/// assert!(s.capacity() >= 10);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve_exact(&mut self, additional: uint) {
self.vec.reserve_exact(additional)
}
@ -433,7 +434,7 @@ impl String {
/// assert_eq!(s.capacity(), 3);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn shrink_to_fit(&mut self) {
self.vec.shrink_to_fit()
}
@ -450,7 +451,7 @@ impl String {
/// assert_eq!(s.as_slice(), "abc123");
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn push(&mut self, ch: char) {
if (ch as u32) < 0x80 {
self.vec.push(ch as u8);
@ -483,7 +484,7 @@ impl String {
/// assert_eq!(s.as_bytes(), b);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
self.vec.as_slice()
}
@ -503,7 +504,7 @@ impl String {
/// assert_eq!(s.as_slice(), "he");
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn truncate(&mut self, new_len: uint) {
assert!(self.is_char_boundary(new_len));
self.vec.truncate(new_len)
@ -522,7 +523,7 @@ impl String {
/// assert_eq!(s.pop(), None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn pop(&mut self) -> Option<char> {
let len = self.len();
if len == 0 {
@ -558,7 +559,7 @@ impl String {
/// assert_eq!(s.remove(0), 'o');
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn remove(&mut self, idx: uint) -> char {
let len = self.len();
assert!(idx <= len);
@ -585,7 +586,7 @@ impl String {
/// If `idx` does not lie on a character boundary or is out of bounds, then
/// this function will panic.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn insert(&mut self, idx: uint, ch: char) {
let len = self.len();
assert!(idx <= len);
@ -622,7 +623,7 @@ impl String {
/// assert_eq!(s.as_slice(), "olleh");
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {
&mut self.vec
}
@ -636,7 +637,7 @@ impl String {
/// assert_eq!(a.len(), 3);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint { self.vec.len() }
/// Returns true if the string contains no bytes
@ -650,7 +651,7 @@ impl String {
/// assert!(!v.is_empty());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool { self.len() == 0 }
/// Truncates the string, returning it to 0 length.
@ -663,7 +664,7 @@ impl String {
/// assert!(s.is_empty());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn clear(&mut self) {
self.vec.clear()
}
@ -672,11 +673,11 @@ impl String {
impl FromUtf8Error {
/// Consume this error, returning the bytes that were attempted to make a
/// `String` with.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_bytes(self) -> Vec<u8> { self.bytes }
/// Access the underlying UTF8-error that was the cause of this error.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn utf8_error(&self) -> Utf8Error { self.error }
}
@ -686,7 +687,7 @@ impl fmt::Show for FromUtf8Error {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl fmt::String for FromUtf8Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt(&self.error, f)
@ -699,14 +700,14 @@ impl fmt::Show for FromUtf16Error {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl fmt::String for FromUtf16Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::String::fmt("invalid utf-16: lone surrogate found", f)
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl FromIterator<char> for String {
fn from_iter<I:Iterator<Item=char>>(iterator: I) -> String {
let mut buf = String::new();
@ -715,7 +716,7 @@ impl FromIterator<char> for String {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> FromIterator<&'a str> for String {
fn from_iter<I:Iterator<Item=&'a str>>(iterator: I) -> String {
let mut buf = String::new();
@ -724,7 +725,8 @@ impl<'a> FromIterator<&'a str> for String {
}
}
#[unstable = "waiting on Extend stabilization"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "waiting on Extend stabilization")]
impl Extend<char> for String {
fn extend<I:Iterator<Item=char>>(&mut self, mut iterator: I) {
let (lower_bound, _) = iterator.size_hint();
@ -735,7 +737,8 @@ impl Extend<char> for String {
}
}
#[unstable = "waiting on Extend stabilization"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "waiting on Extend stabilization")]
impl<'a> Extend<&'a str> for String {
fn extend<I: Iterator<Item=&'a str>>(&mut self, mut iterator: I) {
// A guess that at least one byte per iterator element will be needed.
@ -747,7 +750,7 @@ impl<'a> Extend<&'a str> for String {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialEq for String {
#[inline]
fn eq(&self, other: &String) -> bool { PartialEq::eq(&**self, &**other) }
@ -757,7 +760,7 @@ impl PartialEq for String {
macro_rules! impl_eq {
($lhs:ty, $rhs: ty) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> PartialEq<$rhs> for $lhs {
#[inline]
fn eq(&self, other: &$rhs) -> bool { PartialEq::eq(&**self, &**other) }
@ -765,7 +768,7 @@ macro_rules! impl_eq {
fn ne(&self, other: &$rhs) -> bool { PartialEq::ne(&**self, &**other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> PartialEq<$lhs> for $rhs {
#[inline]
fn eq(&self, other: &$lhs) -> bool { PartialEq::eq(&**self, &**other) }
@ -779,7 +782,7 @@ macro_rules! impl_eq {
impl_eq! { String, &'a str }
impl_eq! { CowString<'a>, String }
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b> PartialEq<&'b str> for CowString<'a> {
#[inline]
fn eq(&self, other: &&'b str) -> bool { PartialEq::eq(&**self, &**other) }
@ -787,7 +790,7 @@ impl<'a, 'b> PartialEq<&'b str> for CowString<'a> {
fn ne(&self, other: &&'b str) -> bool { PartialEq::ne(&**self, &**other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b> PartialEq<CowString<'a>> for &'b str {
#[inline]
fn eq(&self, other: &CowString<'a>) -> bool { PartialEq::eq(&**self, &**other) }
@ -795,25 +798,25 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str {
fn ne(&self, other: &CowString<'a>) -> bool { PartialEq::ne(&**self, &**other) }
}
#[unstable = "waiting on Str stabilization"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Str stabilization")]
impl Str for String {
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn as_slice<'a>(&'a self) -> &'a str {
unsafe { mem::transmute(self.vec.as_slice()) }
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Default for String {
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> String {
String::new()
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl fmt::String for String {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@ -821,7 +824,7 @@ impl fmt::String for String {
}
}
#[unstable = "waiting on fmt stabilization"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on fmt stabilization")]
impl fmt::Show for String {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@ -829,7 +832,7 @@ impl fmt::Show for String {
}
}
#[unstable = "waiting on Hash stabilization"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Hash stabilization")]
impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String {
#[inline]
fn hash(&self, hasher: &mut H) {
@ -837,7 +840,8 @@ impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String {
}
}
#[unstable = "recent addition, needs more experience"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recent addition, needs more experience")]
impl<'a> Add<&'a str> for String {
type Output = String;
@ -877,7 +881,7 @@ impl ops::Index<ops::FullRange> for String {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl ops::Deref for String {
type Target = str;
@ -888,7 +892,7 @@ impl ops::Deref for String {
}
/// Wrapper type providing a `&String` reference via `Deref`.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub struct DerefString<'a> {
x: DerefVec<'a, u8>
}
@ -916,7 +920,7 @@ impl<'a> Deref for DerefString<'a> {
/// let string = as_string("foo").clone();
/// string_consumer(string);
/// ```
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn as_string<'a>(x: &'a str) -> DerefString<'a> {
DerefString { x: as_vec(x.as_bytes()) }
}
@ -960,7 +964,7 @@ impl<'a> IntoCow<'a, String, str> for &'a str {
}
/// A clone-on-write string
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub type CowString<'a> = Cow<'a, String, str>;
impl<'a> Str for CowString<'a> {

134
src/libcollections/vec.rs
View File

@ -44,7 +44,7 @@
//! let two = xs.pop();
//! ```
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use core::prelude::*;
@ -134,7 +134,7 @@ use core::uint;
/// to reallocate, which can be slow. For this reason, it is recommended to use
/// `Vec::with_capacity` whenever possible to specify how big the vector is expected to get.
#[unsafe_no_drop_flag]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Vec<T> {
ptr: NonZero<*mut T>,
len: uint,
@ -159,7 +159,7 @@ impl<T> Vec<T> {
/// let mut vec: Vec<int> = Vec::new();
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> Vec<T> {
// We want ptr to never be NULL so instead we set it to some arbitrary
// non-null value which is fine since we never call deallocate on the ptr
@ -194,7 +194,7 @@ impl<T> Vec<T> {
/// vec.push(11);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn with_capacity(capacity: uint) -> Vec<T> {
if mem::size_of::<T>() == 0 {
Vec { ptr: unsafe { NonZero::new(EMPTY as *mut T) }, len: 0, cap: uint::MAX }
@ -243,7 +243,7 @@ impl<T> Vec<T> {
/// }
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn from_raw_parts(ptr: *mut T, length: uint,
capacity: uint) -> Vec<T> {
Vec { ptr: NonZero::new(ptr), len: length, cap: capacity }
@ -255,7 +255,8 @@ impl<T> Vec<T> {
/// owned by the returned `Vec<T>`. The elements of the buffer are copied into the vector
/// without cloning, as if `ptr::read()` were called on them.
#[inline]
#[unstable = "may be better expressed via composition"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "may be better expressed via composition")]
pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> {
let mut dst = Vec::with_capacity(elts);
dst.set_len(elts);
@ -273,7 +274,7 @@ impl<T> Vec<T> {
/// assert_eq!(vec.capacity(), 10);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn capacity(&self) -> uint {
self.cap
}
@ -292,7 +293,7 @@ impl<T> Vec<T> {
/// vec.reserve(10);
/// assert!(vec.capacity() >= 11);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve(&mut self, additional: uint) {
if self.cap - self.len < additional {
let err_msg = "Vec::reserve: `uint` overflow";
@ -321,7 +322,7 @@ impl<T> Vec<T> {
/// vec.reserve_exact(10);
/// assert!(vec.capacity() >= 11);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve_exact(&mut self, additional: uint) {
if self.cap - self.len < additional {
match self.len.checked_add(additional) {
@ -345,7 +346,7 @@ impl<T> Vec<T> {
/// vec.shrink_to_fit();
/// assert!(vec.capacity() >= 3);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn shrink_to_fit(&mut self) {
if mem::size_of::<T>() == 0 { return }
@ -376,7 +377,7 @@ impl<T> Vec<T> {
/// Note that this will drop any excess capacity. Calling this and
/// converting back to a vector with `into_vec()` is equivalent to calling
/// `shrink_to_fit()`.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn into_boxed_slice(mut self) -> Box<[T]> {
self.shrink_to_fit();
unsafe {
@ -398,7 +399,7 @@ impl<T> Vec<T> {
/// vec.truncate(2);
/// assert_eq!(vec, vec![1, 2]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn truncate(&mut self, len: uint) {
unsafe {
// drop any extra elements
@ -422,7 +423,7 @@ impl<T> Vec<T> {
/// foo(vec.as_mut_slice());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
unsafe {
mem::transmute(RawSlice {
@ -446,7 +447,7 @@ impl<T> Vec<T> {
/// }
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<T> {
unsafe {
let ptr = *self.ptr;
@ -477,7 +478,7 @@ impl<T> Vec<T> {
/// }
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn set_len(&mut self, len: uint) {
self.len = len;
}
@ -503,7 +504,7 @@ impl<T> Vec<T> {
/// assert_eq!(v, vec!["baz", "qux"]);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn swap_remove(&mut self, index: uint) -> T {
let length = self.len();
self.swap(index, length - 1);
@ -527,7 +528,7 @@ impl<T> Vec<T> {
/// vec.insert(4, 5);
/// assert_eq!(vec, vec![1, 4, 2, 3, 5]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn insert(&mut self, index: uint, element: T) {
let len = self.len();
assert!(index <= len);
@ -563,7 +564,7 @@ impl<T> Vec<T> {
/// assert_eq!(v.remove(1), 2);
/// assert_eq!(v, vec![1, 3]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn remove(&mut self, index: uint) -> T {
let len = self.len();
assert!(index < len);
@ -597,7 +598,7 @@ impl<T> Vec<T> {
/// vec.retain(|&x| x%2 == 0);
/// assert_eq!(vec, vec![2, 4]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn retain<F>(&mut self, mut f: F) where F: FnMut(&T) -> bool {
let len = self.len();
let mut del = 0u;
@ -631,7 +632,7 @@ impl<T> Vec<T> {
/// assert_eq!(vec, vec!(1, 2, 3));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn push(&mut self, value: T) {
if mem::size_of::<T>() == 0 {
// zero-size types consume no memory, so we can't rely on the
@ -669,7 +670,7 @@ impl<T> Vec<T> {
/// assert_eq!(vec, vec![1, 2]);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn pop(&mut self) -> Option<T> {
if self.len == 0 {
None
@ -696,7 +697,8 @@ impl<T> Vec<T> {
/// assert_eq!(vec2, vec![]);
/// ```
#[inline]
#[unstable = "new API, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "new API, waiting for dust to settle")]
pub fn append(&mut self, other: &mut Self) {
if mem::size_of::<T>() == 0 {
// zero-size types consume no memory, so we can't rely on the
@ -732,7 +734,8 @@ impl<T> Vec<T> {
/// assert!(v.is_empty());
/// ```
#[inline]
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
unsafe {
let begin = *self.ptr as *const T;
@ -762,7 +765,7 @@ impl<T> Vec<T> {
/// assert!(v.is_empty());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn clear(&mut self) {
self.truncate(0)
}
@ -776,7 +779,7 @@ impl<T> Vec<T> {
/// assert_eq!(a.len(), 3);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint { self.len }
/// Returns `true` if the vector contains no elements.
@ -790,7 +793,7 @@ impl<T> Vec<T> {
/// v.push(1i);
/// assert!(!v.is_empty());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool { self.len() == 0 }
/// Converts a `Vec<T>` to a `Vec<U>` where `T` and `U` have the same
@ -814,7 +817,8 @@ impl<T> Vec<T> {
/// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x));
/// assert_eq!(newtyped_bytes.as_slice(), [Newtype(0x11), Newtype(0x22)].as_slice());
/// ```
#[unstable = "API may change to provide stronger guarantees"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "API may change to provide stronger guarantees")]
pub fn map_in_place<U, F>(self, mut f: F) -> Vec<U> where F: FnMut(T) -> U {
// FIXME: Assert statically that the types `T` and `U` have the same
// size.
@ -1008,7 +1012,8 @@ impl<T: Clone> Vec<T> {
/// vec.resize(2, 0);
/// assert_eq!(vec, vec![1, 2]);
/// ```
#[unstable = "matches collection reform specification; waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification; waiting for dust to settle")]
pub fn resize(&mut self, new_len: uint, value: T) {
let len = self.len();
@ -1032,7 +1037,8 @@ impl<T: Clone> Vec<T> {
/// assert_eq!(vec, vec![1, 2, 3, 4]);
/// ```
#[inline]
#[unstable = "likely to be replaced by a more optimized extend"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to be replaced by a more optimized extend")]
pub fn push_all(&mut self, other: &[T]) {
self.reserve(other.len());
@ -1066,7 +1072,7 @@ impl<T: PartialEq> Vec<T> {
///
/// assert_eq!(vec, vec![1i, 2, 3, 2]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn dedup(&mut self) {
unsafe {
// Although we have a mutable reference to `self`, we cannot make
@ -1200,7 +1206,7 @@ unsafe fn dealloc<T>(ptr: *mut T, len: uint) {
// Common trait implementations for Vec
////////////////////////////////////////////////////////////////////////////////
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<T:Clone> Clone for Vec<T> {
fn clone(&self) -> Vec<T> { ::slice::SliceExt::to_vec(self.as_slice()) }
@ -1229,7 +1235,7 @@ impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> {
}
}
#[unstable = "waiting on Index stability"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Index stability")]
impl<T> Index<uint> for Vec<T> {
type Output = T;
@ -1308,19 +1314,19 @@ impl<T> ops::IndexMut<ops::FullRange> for Vec<T> {
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> ops::Deref for Vec<T> {
type Target = [T];
fn deref<'a>(&'a self) -> &'a [T] { self.as_slice() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> ops::DerefMut for Vec<T> {
fn deref_mut<'a>(&'a mut self) -> &'a mut [T] { self.as_mut_slice() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> FromIterator<T> for Vec<T> {
#[inline]
fn from_iter<I:Iterator<Item=T>>(mut iterator: I) -> Vec<T> {
@ -1333,7 +1339,7 @@ impl<T> FromIterator<T> for Vec<T> {
}
}
#[unstable = "waiting on Extend stability"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Extend stability")]
impl<T> Extend<T> for Vec<T> {
#[inline]
fn extend<I: Iterator<Item=T>>(&mut self, mut iterator: I) {
@ -1408,7 +1414,8 @@ macro_rules! impl_eq_for_cowvec {
impl_eq_for_cowvec! { &'b [B] }
impl_eq_for_cowvec! { &'b mut [B] }
#[unstable = "waiting on PartialOrd stability"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "waiting on PartialOrd stability")]
impl<T: PartialOrd> PartialOrd for Vec<T> {
#[inline]
fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering> {
@ -1416,10 +1423,10 @@ impl<T: PartialOrd> PartialOrd for Vec<T> {
}
}
#[unstable = "waiting on Eq stability"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Eq stability")]
impl<T: Eq> Eq for Vec<T> {}
#[unstable = "waiting on Ord stability"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Ord stability")]
impl<T: Ord> Ord for Vec<T> {
#[inline]
fn cmp(&self, other: &Vec<T>) -> Ordering {
@ -1439,7 +1446,7 @@ impl<T> AsSlice<T> for Vec<T> {
/// foo(vec.as_slice());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn as_slice<'a>(&'a self) -> &'a [T] {
unsafe {
mem::transmute(RawSlice {
@ -1450,7 +1457,8 @@ impl<T> AsSlice<T> for Vec<T> {
}
}
#[unstable = "recent addition, needs more experience"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recent addition, needs more experience")]
impl<'a, T: Clone> Add<&'a [T]> for Vec<T> {
type Output = Vec<T>;
@ -1462,7 +1470,7 @@ impl<'a, T: Clone> Add<&'a [T]> for Vec<T> {
}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Drop for Vec<T> {
fn drop(&mut self) {
// This is (and should always remain) a no-op if the fields are
@ -1478,15 +1486,15 @@ impl<T> Drop for Vec<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Default for Vec<T> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> Vec<T> {
Vec::new()
}
}
#[unstable = "waiting on Show stability"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Show stability")]
impl<T: fmt::Show> fmt::Show for Vec<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(self.as_slice(), f)
@ -1504,11 +1512,12 @@ impl<'a> fmt::Writer for Vec<u8> {
// Clone-on-write
////////////////////////////////////////////////////////////////////////////////
#[unstable = "unclear how valuable this alias is"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "unclear how valuable this alias is")]
/// A clone-on-write vector
pub type CowVec<'a, T> = Cow<'a, Vec<T>, [T]>;
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> FromIterator<T> for CowVec<'a, T> where T: Clone {
fn from_iter<I: Iterator<Item=T>>(it: I) -> CowVec<'a, T> {
Cow::Owned(FromIterator::from_iter(it))
@ -1532,7 +1541,7 @@ impl<'a, T> IntoCow<'a, Vec<T>, [T]> for &'a [T] where T: Clone {
////////////////////////////////////////////////////////////////////////////////
/// An iterator that moves out of a vector.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IntoIter<T> {
allocation: *mut T, // the block of memory allocated for the vector
cap: uint, // the capacity of the vector
@ -1546,7 +1555,7 @@ unsafe impl<T: Sync> Sync for IntoIter<T> { }
impl<T> IntoIter<T> {
#[inline]
/// Drops all items that have not yet been moved and returns the empty vector.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn into_inner(mut self) -> Vec<T> {
unsafe {
for _x in self { }
@ -1557,7 +1566,7 @@ impl<T> IntoIter<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Iterator for IntoIter<T> {
type Item = T;
@ -1594,7 +1603,7 @@ impl<T> Iterator for IntoIter<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
#[inline]
fn next_back<'a>(&'a mut self) -> Option<T> {
@ -1618,11 +1627,11 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> ExactSizeIterator for IntoIter<T> {}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Drop for IntoIter<T> {
fn drop(&mut self) {
// destroy the remaining elements
@ -1637,14 +1646,15 @@ impl<T> Drop for IntoIter<T> {
/// An iterator that drains a vector.
#[unsafe_no_drop_flag]
#[unstable = "recently added as part of collections reform 2"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recently added as part of collections reform 2")]
pub struct Drain<'a, T> {
ptr: *const T,
end: *const T,
marker: ContravariantLifetime<'a>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for Drain<'a, T> {
type Item = T;
@ -1681,7 +1691,7 @@ impl<'a, T> Iterator for Drain<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<T> {
@ -1705,11 +1715,11 @@ impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Drain<'a, T> {}
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Drop for Drain<'a, T> {
fn drop(&mut self) {
// self.ptr == self.end == null if drop has already been called,
@ -1725,13 +1735,13 @@ impl<'a, T> Drop for Drain<'a, T> {
////////////////////////////////////////////////////////////////////////////////
/// Wrapper type providing a `&Vec<T>` reference via `Deref`.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub struct DerefVec<'a, T> {
x: Vec<T>,
l: ContravariantLifetime<'a>
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> Deref for DerefVec<'a, T> {
type Target = Vec<T>;
@ -1742,7 +1752,7 @@ impl<'a, T> Deref for DerefVec<'a, T> {
// Prevent the inner `Vec<T>` from attempting to deallocate memory.
#[unsafe_destructor]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Drop for DerefVec<'a, T> {
fn drop(&mut self) {
self.x.len = 0;
@ -1751,7 +1761,7 @@ impl<'a, T> Drop for DerefVec<'a, T> {
}
/// Convert a slice to a wrapper type providing a `&Vec<T>` reference.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> {
unsafe {
DerefVec {

91
src/libcollections/vec_map.rs
View File

@ -66,9 +66,9 @@ pub struct VecMap<V> {
v: Vec<Option<V>>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V> Default for VecMap<V> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn default() -> VecMap<V> { VecMap::new() }
}
@ -107,7 +107,7 @@ impl<V> VecMap<V> {
/// use std::collections::VecMap;
/// let mut map: VecMap<&str> = VecMap::new();
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new() -> VecMap<V> { VecMap { v: vec![] } }
/// Creates an empty `VecMap` with space for at least `capacity`
@ -119,7 +119,7 @@ impl<V> VecMap<V> {
/// use std::collections::VecMap;
/// let mut map: VecMap<&str> = VecMap::with_capacity(10);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn with_capacity(capacity: uint) -> VecMap<V> {
VecMap { v: Vec::with_capacity(capacity) }
}
@ -135,7 +135,7 @@ impl<V> VecMap<V> {
/// assert!(map.capacity() >= 10);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn capacity(&self) -> uint {
self.v.capacity()
}
@ -154,7 +154,7 @@ impl<V> VecMap<V> {
/// map.reserve_len(10);
/// assert!(map.capacity() >= 10);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve_len(&mut self, len: uint) {
let cur_len = self.v.len();
if len >= cur_len {
@ -178,7 +178,7 @@ impl<V> VecMap<V> {
/// map.reserve_len_exact(10);
/// assert!(map.capacity() >= 10);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reserve_len_exact(&mut self, len: uint) {
let cur_len = self.v.len();
if len >= cur_len {
@ -188,7 +188,7 @@ impl<V> VecMap<V> {
/// Returns an iterator visiting all keys in ascending order of the keys.
/// The iterator's element type is `uint`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn keys<'r>(&'r self) -> Keys<'r, V> {
fn first<A, B>((a, _): (A, B)) -> A { a }
let first: fn((uint, &'r V)) -> uint = first; // coerce to fn pointer
@ -198,7 +198,7 @@ impl<V> VecMap<V> {
/// Returns an iterator visiting all values in ascending order of the keys.
/// The iterator's element type is `&'r V`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn values<'r>(&'r self) -> Values<'r, V> {
fn second<A, B>((_, b): (A, B)) -> B { b }
let second: fn((uint, &'r V)) -> &'r V = second; // coerce to fn pointer
@ -224,7 +224,7 @@ impl<V> VecMap<V> {
/// println!("{}: {}", key, value);
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter<'r>(&'r self) -> Iter<'r, V> {
Iter {
front: 0,
@ -255,7 +255,7 @@ impl<V> VecMap<V> {
/// assert_eq!(value, &"x");
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter_mut<'r>(&'r mut self) -> IterMut<'r, V> {
IterMut {
front: 0,
@ -282,7 +282,7 @@ impl<V> VecMap<V> {
///
/// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<V> {
fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
v.map(|v| (i, v))
@ -310,7 +310,8 @@ impl<V> VecMap<V> {
///
/// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
/// ```
#[unstable = "matches collection reform specification, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "matches collection reform specification, waiting for dust to settle")]
pub fn drain<'a>(&'a mut self) -> Drain<'a, V> {
fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
v.map(|v| (i, v))
@ -332,7 +333,7 @@ impl<V> VecMap<V> {
/// a.insert(1, "a");
/// assert_eq!(a.len(), 1);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn len(&self) -> uint {
self.v.iter().filter(|elt| elt.is_some()).count()
}
@ -349,7 +350,7 @@ impl<V> VecMap<V> {
/// a.insert(1, "a");
/// assert!(!a.is_empty());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_empty(&self) -> bool {
self.v.iter().all(|elt| elt.is_none())
}
@ -366,7 +367,7 @@ impl<V> VecMap<V> {
/// a.clear();
/// assert!(a.is_empty());
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn clear(&mut self) { self.v.clear() }
/// Returns a reference to the value corresponding to the key.
@ -381,7 +382,7 @@ impl<V> VecMap<V> {
/// assert_eq!(map.get(&1), Some(&"a"));
/// assert_eq!(map.get(&2), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn get(&self, key: &uint) -> Option<&V> {
if *key < self.v.len() {
match self.v[*key] {
@ -406,7 +407,7 @@ impl<V> VecMap<V> {
/// assert_eq!(map.contains_key(&2), false);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn contains_key(&self, key: &uint) -> bool {
self.get(key).is_some()
}
@ -426,7 +427,7 @@ impl<V> VecMap<V> {
/// }
/// assert_eq!(map[1], "b");
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn get_mut(&mut self, key: &uint) -> Option<&mut V> {
if *key < self.v.len() {
match *(&mut self.v[*key]) {
@ -454,7 +455,7 @@ impl<V> VecMap<V> {
/// assert_eq!(map.insert(37, "c"), Some("b"));
/// assert_eq!(map[37], "c");
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn insert(&mut self, key: uint, value: V) -> Option<V> {
let len = self.v.len();
if len <= key {
@ -476,7 +477,7 @@ impl<V> VecMap<V> {
/// assert_eq!(map.remove(&1), Some("a"));
/// assert_eq!(map.remove(&1), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn remove(&mut self, key: &uint) -> Option<V> {
if *key >= self.v.len() {
return None;
@ -486,17 +487,17 @@ impl<V> VecMap<V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V: PartialEq> PartialEq for VecMap<V> {
fn eq(&self, other: &VecMap<V>) -> bool {
iter::order::eq(self.iter(), other.iter())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V: Eq> Eq for VecMap<V> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V: PartialOrd> PartialOrd for VecMap<V> {
#[inline]
fn partial_cmp(&self, other: &VecMap<V>) -> Option<Ordering> {
@ -504,7 +505,7 @@ impl<V: PartialOrd> PartialOrd for VecMap<V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V: Ord> Ord for VecMap<V> {
#[inline]
fn cmp(&self, other: &VecMap<V>) -> Ordering {
@ -512,7 +513,7 @@ impl<V: Ord> Ord for VecMap<V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V: fmt::Show> fmt::Show for VecMap<V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, "VecMap {{"));
@ -526,7 +527,7 @@ impl<V: fmt::Show> fmt::Show for VecMap<V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V> FromIterator<(uint, V)> for VecMap<V> {
fn from_iter<Iter: Iterator<Item=(uint, V)>>(iter: Iter) -> VecMap<V> {
let mut map = VecMap::new();
@ -535,7 +536,7 @@ impl<V> FromIterator<(uint, V)> for VecMap<V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V> Extend<(uint, V)> for VecMap<V> {
fn extend<Iter: Iterator<Item=(uint, V)>>(&mut self, mut iter: Iter) {
for (k, v) in iter {
@ -553,7 +554,7 @@ impl<V> Index<uint> for VecMap<V> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V> IndexMut<uint> for VecMap<V> {
type Output = V;
@ -565,7 +566,7 @@ impl<V> IndexMut<uint> for VecMap<V> {
macro_rules! iterator {
(impl $name:ident -> $elem:ty, $($getter:ident),+) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, V> Iterator for $name<'a, V> {
type Item = $elem;
@ -600,7 +601,7 @@ macro_rules! iterator {
macro_rules! double_ended_iterator {
(impl $name:ident -> $elem:ty, $($getter:ident),+) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, V> DoubleEndedIterator for $name<'a, V> {
#[inline]
fn next_back(&mut self) -> Option<$elem> {
@ -626,7 +627,7 @@ macro_rules! double_ended_iterator {
}
/// An iterator over the key-value pairs of a map.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Iter<'a, V:'a> {
front: uint,
back: uint,
@ -649,7 +650,7 @@ double_ended_iterator! { impl Iter -> (uint, &'a V), as_ref }
/// An iterator over the key-value pairs of a map, with the
/// values being mutable.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IterMut<'a, V:'a> {
front: uint,
back: uint,
@ -660,7 +661,7 @@ iterator! { impl IterMut -> (uint, &'a mut V), as_mut }
double_ended_iterator! { impl IterMut -> (uint, &'a mut V), as_mut }
/// An iterator over the keys of a map.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Keys<'a, V: 'a> {
iter: Map<(uint, &'a V), uint, Iter<'a, V>, fn((uint, &'a V)) -> uint>
}
@ -675,7 +676,7 @@ impl<'a, V> Clone for Keys<'a, V> {
}
/// An iterator over the values of a map.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Values<'a, V: 'a> {
iter: Map<(uint, &'a V), &'a V, Iter<'a, V>, fn((uint, &'a V)) -> &'a V>
}
@ -690,7 +691,7 @@ impl<'a, V> Clone for Values<'a, V> {
}
/// A consuming iterator over the key-value pairs of a map.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IntoIter<V> {
iter: FilterMap<
(uint, Option<V>),
@ -699,7 +700,7 @@ pub struct IntoIter<V> {
fn((uint, Option<V>)) -> Option<(uint, V)>>
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub struct Drain<'a, V> {
iter: FilterMap<
(uint, Option<V>),
@ -708,7 +709,7 @@ pub struct Drain<'a, V> {
fn((uint, Option<V>)) -> Option<(uint, V)>>
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, V> Iterator for Drain<'a, V> {
type Item = (uint, V);
@ -716,43 +717,43 @@ impl<'a, V> Iterator for Drain<'a, V> {
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, V> DoubleEndedIterator for Drain<'a, V> {
fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, V> Iterator for Keys<'a, V> {
type Item = uint;
fn next(&mut self) -> Option<uint> { self.iter.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, V> DoubleEndedIterator for Keys<'a, V> {
fn next_back(&mut self) -> Option<uint> { self.iter.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, V> Iterator for Values<'a, V> {
type Item = &'a V;
fn next(&mut self) -> Option<(&'a V)> { self.iter.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, V> DoubleEndedIterator for Values<'a, V> {
fn next_back(&mut self) -> Option<(&'a V)> { self.iter.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V> Iterator for IntoIter<V> {
type Item = (uint, V);
fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<V> DoubleEndedIterator for IntoIter<V> {
fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
}

18
src/libcore/any.rs
View File

@ -69,7 +69,7 @@
//! }
//! ```
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use mem::transmute;
use option::Option::{self, Some, None};
@ -86,10 +86,11 @@ use intrinsics;
///
/// Every type with no non-`'static` references implements `Any`, so `Any` can
/// be used as a trait object to emulate the effects dynamic typing.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Any: 'static {
/// Get the `TypeId` of `self`
#[unstable = "this method will likely be replaced by an associated static"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this method will likely be replaced by an associated static")]
fn get_type_id(&self) -> TypeId;
}
@ -103,7 +104,7 @@ impl<T: 'static> Any for T {
impl Any {
/// Returns true if the boxed type is the same as `T`
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
pub fn is<T: 'static>(&self) -> bool {
// Get TypeId of the type this function is instantiated with
@ -118,7 +119,7 @@ impl Any {
/// Returns some reference to the boxed value if it is of type `T`, or
/// `None` if it isn't.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
if self.is::<T>() {
@ -136,7 +137,7 @@ impl Any {
/// Returns some mutable reference to the boxed value if it is of type `T`, or
/// `None` if it isn't.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut T> {
if self.is::<T>() {
@ -167,7 +168,7 @@ impl Any {
/// but this limitation may be removed in the future.
#[cfg_attr(stage0, lang = "type_id")]
#[derive(Clone, Copy, PartialEq, Eq, Show, Hash)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct TypeId {
t: u64,
}
@ -176,7 +177,8 @@ impl TypeId {
/// Returns the `TypeId` of the type this generic function has been
/// instantiated with
#[cfg(not(stage0))]
#[unstable = "may grow a `Reflect` bound soon via marker traits"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "may grow a `Reflect` bound soon via marker traits")]
pub fn of<T: ?Sized + 'static>() -> TypeId {
TypeId {
t: unsafe { intrinsics::type_id::<T>() },

19
src/libcore/array.rs
View File

@ -12,7 +12,7 @@
//! up to a certain length. Eventually we should able to generalize
//! to all lengths.
#![unstable] // not yet reviewed
#![unstable(feature = "unnamed_feature", since = "1.0.0")] // not yet reviewed
use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
@ -26,7 +26,7 @@ use option::Option;
macro_rules! array_impls {
($($N:expr)+) => {
$(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T:Copy> Clone for [T; $N] {
fn clone(&self) -> [T; $N] {
*self
@ -39,14 +39,15 @@ macro_rules! array_impls {
}
}
#[unstable = "waiting for Show to stabilize"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "waiting for Show to stabilize")]
impl<T:fmt::Show> fmt::Show for [T; $N] {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt(&&self[], f)
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A, B> PartialEq<[B; $N]> for [A; $N] where A: PartialEq<B> {
#[inline]
fn eq(&self, other: &[B; $N]) -> bool {
@ -58,7 +59,7 @@ macro_rules! array_impls {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A, B, Rhs> PartialEq<Rhs> for [A; $N] where
A: PartialEq<B>,
Rhs: Deref<Target=[B]>,
@ -73,7 +74,7 @@ macro_rules! array_impls {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A, B, Lhs> PartialEq<[B; $N]> for Lhs where
A: PartialEq<B>,
Lhs: Deref<Target=[A]>
@ -88,10 +89,10 @@ macro_rules! array_impls {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T:Eq> Eq for [T; $N] { }
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T:PartialOrd> PartialOrd for [T; $N] {
#[inline]
fn partial_cmp(&self, other: &[T; $N]) -> Option<Ordering> {
@ -115,7 +116,7 @@ macro_rules! array_impls {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T:Ord> Ord for [T; $N] {
#[inline]
fn cmp(&self, other: &[T; $N]) -> Ordering {

92
src/libcore/atomic.rs
View File

@ -68,7 +68,7 @@
//! println!("live tasks: {}", old_task_count + 1);
//! ```
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use self::Ordering::*;
@ -78,7 +78,7 @@ use intrinsics;
use cell::UnsafeCell;
/// A boolean type which can be safely shared between threads.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct AtomicBool {
v: UnsafeCell<usize>,
}
@ -86,7 +86,7 @@ pub struct AtomicBool {
unsafe impl Sync for AtomicBool {}
/// A signed integer type which can be safely shared between threads.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct AtomicIsize {
v: UnsafeCell<isize>,
}
@ -94,7 +94,7 @@ pub struct AtomicIsize {
unsafe impl Sync for AtomicIsize {}
/// An unsigned integer type which can be safely shared between threads.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct AtomicUsize {
v: UnsafeCell<usize>,
}
@ -102,7 +102,7 @@ pub struct AtomicUsize {
unsafe impl Sync for AtomicUsize {}
/// A raw pointer type which can be safely shared between threads.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct AtomicPtr<T> {
p: UnsafeCell<usize>,
}
@ -119,42 +119,42 @@ unsafe impl<T> Sync for AtomicPtr<T> {}
///
/// Rust's memory orderings are [the same as
/// C++'s](http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync).
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[derive(Copy)]
pub enum Ordering {
/// No ordering constraints, only atomic operations.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
Relaxed,
/// When coupled with a store, all previous writes become visible
/// to another thread that performs a load with `Acquire` ordering
/// on the same value.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
Release,
/// When coupled with a load, all subsequent loads will see data
/// written before a store with `Release` ordering on the same value
/// in another thread.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
Acquire,
/// When coupled with a load, uses `Acquire` ordering, and with a store
/// `Release` ordering.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
AcqRel,
/// Like `AcqRel` with the additional guarantee that all threads see all
/// sequentially consistent operations in the same order.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
SeqCst,
}
/// An `AtomicBool` initialized to `false`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const ATOMIC_BOOL_INIT: AtomicBool =
AtomicBool { v: UnsafeCell { value: 0 } };
/// An `AtomicIsize` initialized to `0`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const ATOMIC_ISIZE_INIT: AtomicIsize =
AtomicIsize { v: UnsafeCell { value: 0 } };
/// An `AtomicUsize` initialized to `0`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const ATOMIC_USIZE_INIT: AtomicUsize =
AtomicUsize { v: UnsafeCell { value: 0, } };
@ -173,7 +173,7 @@ impl AtomicBool {
/// let atomic_false = AtomicBool::new(false);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new(v: bool) -> AtomicBool {
let val = if v { UINT_TRUE } else { 0 };
AtomicBool { v: UnsafeCell::new(val) }
@ -197,7 +197,7 @@ impl AtomicBool {
/// let value = some_bool.load(Ordering::Relaxed);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn load(&self, order: Ordering) -> bool {
unsafe { atomic_load(self.v.get(), order) > 0 }
}
@ -220,7 +220,7 @@ impl AtomicBool {
///
/// Panics if `order` is `Acquire` or `AcqRel`.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn store(&self, val: bool, order: Ordering) {
let val = if val { UINT_TRUE } else { 0 };
@ -241,7 +241,7 @@ impl AtomicBool {
/// let value = some_bool.swap(false, Ordering::Relaxed);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn swap(&self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };
@ -265,7 +265,7 @@ impl AtomicBool {
/// let value = some_bool.store(false, Ordering::Relaxed);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn compare_and_swap(&self, old: bool, new: bool, order: Ordering) -> bool {
let old = if old { UINT_TRUE } else { 0 };
let new = if new { UINT_TRUE } else { 0 };
@ -298,7 +298,7 @@ impl AtomicBool {
/// assert_eq!(false, foo.load(Ordering::SeqCst));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn fetch_and(&self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };
@ -331,7 +331,7 @@ impl AtomicBool {
/// assert_eq!(true, foo.load(Ordering::SeqCst));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn fetch_nand(&self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };
@ -363,7 +363,7 @@ impl AtomicBool {
/// assert_eq!(false, foo.load(Ordering::SeqCst));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn fetch_or(&self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };
@ -395,7 +395,7 @@ impl AtomicBool {
/// assert_eq!(false, foo.load(Ordering::SeqCst));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn fetch_xor(&self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };
@ -403,7 +403,7 @@ impl AtomicBool {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl AtomicIsize {
/// Creates a new `AtomicIsize`.
///
@ -580,7 +580,7 @@ impl AtomicIsize {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl AtomicUsize {
/// Creates a new `AtomicUsize`.
///
@ -769,7 +769,7 @@ impl<T> AtomicPtr<T> {
/// let atomic_ptr = AtomicPtr::new(ptr);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new(p: *mut T) -> AtomicPtr<T> {
AtomicPtr { p: UnsafeCell::new(p as usize) }
}
@ -793,7 +793,7 @@ impl<T> AtomicPtr<T> {
/// let value = some_ptr.load(Ordering::Relaxed);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn load(&self, order: Ordering) -> *mut T {
unsafe {
atomic_load(self.p.get(), order) as *mut T
@ -821,7 +821,7 @@ impl<T> AtomicPtr<T> {
///
/// Panics if `order` is `Acquire` or `AcqRel`.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn store(&self, ptr: *mut T, order: Ordering) {
unsafe { atomic_store(self.p.get(), ptr as usize, order); }
}
@ -843,7 +843,7 @@ impl<T> AtomicPtr<T> {
/// let value = some_ptr.swap(other_ptr, Ordering::Relaxed);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn swap(&self, ptr: *mut T, order: Ordering) -> *mut T {
unsafe { atomic_swap(self.p.get(), ptr as usize, order) as *mut T }
}
@ -869,7 +869,7 @@ impl<T> AtomicPtr<T> {
/// let value = some_ptr.compare_and_swap(other_ptr, another_ptr, Ordering::Relaxed);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn compare_and_swap(&self, old: *mut T, new: *mut T, order: Ordering) -> *mut T {
unsafe {
atomic_compare_and_swap(self.p.get(), old as usize,
@ -890,7 +890,7 @@ unsafe fn atomic_store<T>(dst: *mut T, val: T, order:Ordering) {
}
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn atomic_load<T>(dst: *const T, order:Ordering) -> T {
match order {
Acquire => intrinsics::atomic_load_acq(dst),
@ -902,7 +902,7 @@ unsafe fn atomic_load<T>(dst: *const T, order:Ordering) -> T {
}
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn atomic_swap<T>(dst: *mut T, val: T, order: Ordering) -> T {
match order {
Acquire => intrinsics::atomic_xchg_acq(dst, val),
@ -915,7 +915,7 @@ unsafe fn atomic_swap<T>(dst: *mut T, val: T, order: Ordering) -> T {
/// Returns the old value (like __sync_fetch_and_add).
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn atomic_add<T>(dst: *mut T, val: T, order: Ordering) -> T {
match order {
Acquire => intrinsics::atomic_xadd_acq(dst, val),
@ -928,7 +928,7 @@ unsafe fn atomic_add<T>(dst: *mut T, val: T, order: Ordering) -> T {
/// Returns the old value (like __sync_fetch_and_sub).
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn atomic_sub<T>(dst: *mut T, val: T, order: Ordering) -> T {
match order {
Acquire => intrinsics::atomic_xsub_acq(dst, val),
@ -940,7 +940,7 @@ unsafe fn atomic_sub<T>(dst: *mut T, val: T, order: Ordering) -> T {
}
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn atomic_compare_and_swap<T>(dst: *mut T, old:T, new:T, order: Ordering) -> T {
match order {
Acquire => intrinsics::atomic_cxchg_acq(dst, old, new),
@ -952,7 +952,7 @@ unsafe fn atomic_compare_and_swap<T>(dst: *mut T, old:T, new:T, order: Ordering)
}
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn atomic_and<T>(dst: *mut T, val: T, order: Ordering) -> T {
match order {
Acquire => intrinsics::atomic_and_acq(dst, val),
@ -964,7 +964,7 @@ unsafe fn atomic_and<T>(dst: *mut T, val: T, order: Ordering) -> T {
}
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn atomic_nand<T>(dst: *mut T, val: T, order: Ordering) -> T {
match order {
Acquire => intrinsics::atomic_nand_acq(dst, val),
@ -977,7 +977,7 @@ unsafe fn atomic_nand<T>(dst: *mut T, val: T, order: Ordering) -> T {
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn atomic_or<T>(dst: *mut T, val: T, order: Ordering) -> T {
match order {
Acquire => intrinsics::atomic_or_acq(dst, val),
@ -990,7 +990,7 @@ unsafe fn atomic_or<T>(dst: *mut T, val: T, order: Ordering) -> T {
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn atomic_xor<T>(dst: *mut T, val: T, order: Ordering) -> T {
match order {
Acquire => intrinsics::atomic_xor_acq(dst, val),
@ -1023,7 +1023,7 @@ unsafe fn atomic_xor<T>(dst: *mut T, val: T, order: Ordering) -> T {
///
/// Panics if `order` is `Relaxed`.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn fence(order: Ordering) {
unsafe {
match order {
@ -1036,7 +1036,8 @@ pub fn fence(order: Ordering) {
}
}
#[deprecated="renamed to AtomicIsize"]
#[deprecated(feature = "unnamed_feature", since = "1.0.0",
reason = "renamed to AtomicIsize")]
#[allow(missing_docs)]
pub struct AtomicInt {
v: UnsafeCell<int>,
@ -1044,7 +1045,8 @@ pub struct AtomicInt {
unsafe impl Sync for AtomicInt {}
#[deprecated="renamed to AtomicUsize"]
#[deprecated(feature = "unnamed_feature", since = "1.0.0",
reason = "renamed to AtomicUsize")]
#[allow(missing_docs)]
pub struct AtomicUint {
v: UnsafeCell<uint>,
@ -1052,11 +1054,13 @@ pub struct AtomicUint {
unsafe impl Sync for AtomicUint {}
#[deprecated="use ATOMIC_ISIZE_INIT instead"]
#[deprecated(feature = "unnamed_feature", since = "1.0.0",
reason = "use ATOMIC_ISIZE_INIT instead")]
#[allow(missing_docs, deprecated)]
pub const ATOMIC_INT_INIT: AtomicInt =
AtomicInt { v: UnsafeCell { value: 0 } };
#[deprecated="use ATOMIC_USIZE_INIT instead"]
#[deprecated(feature = "unnamed_feature", since = "1.0.0",
reason = "use ATOMIC_USIZE_INIT instead")]
#[allow(missing_docs, deprecated)]
pub const ATOMIC_UINT_INIT: AtomicUint =
AtomicUint { v: UnsafeCell { value: 0, } };

17
src/libcore/borrow.rs
View File

@ -42,7 +42,8 @@
//! is desired, `to_mut` will obtain a mutable references to an owned
//! value, cloning if necessary.
#![unstable = "recently added as part of collections reform"]
#![unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recently added as part of collections reform")]
use clone::Clone;
use cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
@ -142,7 +143,7 @@ pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> {
Owned(T)
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, B: ?Sized> Clone for Cow<'a, T, B> where B: ToOwned<T> {
fn clone(&self) -> Cow<'a, T, B> {
match *self {
@ -196,7 +197,7 @@ impl<'a, T, B: ?Sized> Cow<'a, T, B> where B: ToOwned<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, B: ?Sized> Deref for Cow<'a, T, B> where B: ToOwned<T> {
type Target = B;
@ -208,10 +209,10 @@ impl<'a, T, B: ?Sized> Deref for Cow<'a, T, B> where B: ToOwned<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, B: ?Sized> Eq for Cow<'a, T, B> where B: Eq + ToOwned<T> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, B: ?Sized> Ord for Cow<'a, T, B> where B: Ord + ToOwned<T> {
#[inline]
fn cmp(&self, other: &Cow<'a, T, B>) -> Ordering {
@ -219,7 +220,7 @@ impl<'a, T, B: ?Sized> Ord for Cow<'a, T, B> where B: Ord + ToOwned<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, T, U, B: ?Sized, C: ?Sized> PartialEq<Cow<'b, U, C>> for Cow<'a, T, B> where
B: PartialEq<C> + ToOwned<T>,
C: ToOwned<U>,
@ -230,7 +231,7 @@ impl<'a, 'b, T, U, B: ?Sized, C: ?Sized> PartialEq<Cow<'b, U, C>> for Cow<'a, T,
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, B: ?Sized> PartialOrd for Cow<'a, T, B> where B: PartialOrd + ToOwned<T> {
#[inline]
fn partial_cmp(&self, other: &Cow<'a, T, B>) -> Option<Ordering> {
@ -238,7 +239,7 @@ impl<'a, T, B: ?Sized> PartialOrd for Cow<'a, T, B> where B: PartialOrd + ToOwne
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, B: ?Sized> fmt::String for Cow<'a, T, B> where
B: fmt::String + ToOwned<T>,
T: fmt::String,

71
src/libcore/cell.rs
View File

@ -154,7 +154,7 @@
// FIXME: Can't be shared between threads. Dynamic borrows
// FIXME: Relationship to Atomic types and RWLock
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use clone::Clone;
use cmp::PartialEq;
@ -165,14 +165,14 @@ use option::Option;
use option::Option::{None, Some};
/// A mutable memory location that admits only `Copy` data.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Cell<T> {
value: UnsafeCell<T>,
}
impl<T:Copy> Cell<T> {
/// Creates a new `Cell` containing the given value.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new(value: T) -> Cell<T> {
Cell {
value: UnsafeCell::new(value),
@ -181,14 +181,14 @@ impl<T:Copy> Cell<T> {
/// Returns a copy of the contained value.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn get(&self) -> T {
unsafe{ *self.value.get() }
}
/// Sets the contained value.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn set(&self, value: T) {
unsafe {
*self.value.get() = value;
@ -201,31 +201,31 @@ impl<T:Copy> Cell<T> {
///
/// This function is `unsafe` because `UnsafeCell`'s field is public.
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
&self.value
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe impl<T> Send for Cell<T> where T: Send {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T:Copy> Clone for Cell<T> {
fn clone(&self) -> Cell<T> {
Cell::new(self.get())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T:Default + Copy> Default for Cell<T> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> Cell<T> {
Cell::new(Default::default())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T:PartialEq + Copy> PartialEq for Cell<T> {
fn eq(&self, other: &Cell<T>) -> bool {
self.get() == other.get()
@ -233,7 +233,7 @@ impl<T:PartialEq + Copy> PartialEq for Cell<T> {
}
/// A mutable memory location with dynamically checked borrow rules
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct RefCell<T> {
value: UnsafeCell<T>,
borrow: Cell<BorrowFlag>,
@ -247,7 +247,7 @@ const WRITING: BorrowFlag = -1;
impl<T> RefCell<T> {
/// Create a new `RefCell` containing `value`
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new(value: T) -> RefCell<T> {
RefCell {
value: UnsafeCell::new(value),
@ -256,7 +256,7 @@ impl<T> RefCell<T> {
}
/// Consumes the `RefCell`, returning the wrapped value.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_inner(self) -> T {
// Since this function takes `self` (the `RefCell`) by value, the
// compiler statically verifies that it is not currently borrowed.
@ -271,7 +271,7 @@ impl<T> RefCell<T> {
/// immutable borrows can be taken out at the same time.
///
/// Returns `None` if the value is currently mutably borrowed.
#[unstable = "may be renamed or removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed or removed")]
pub fn try_borrow<'a>(&'a self) -> Option<Ref<'a, T>> {
match BorrowRef::new(&self.borrow) {
Some(b) => Some(Ref { _value: unsafe { &*self.value.get() }, _borrow: b }),
@ -287,7 +287,7 @@ impl<T> RefCell<T> {
/// # Panics
///
/// Panics if the value is currently mutably borrowed.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn borrow<'a>(&'a self) -> Ref<'a, T> {
match self.try_borrow() {
Some(ptr) => ptr,
@ -301,7 +301,7 @@ impl<T> RefCell<T> {
/// cannot be borrowed while this borrow is active.
///
/// Returns `None` if the value is currently borrowed.
#[unstable = "may be renamed or removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed or removed")]
pub fn try_borrow_mut<'a>(&'a self) -> Option<RefMut<'a, T>> {
match BorrowRefMut::new(&self.borrow) {
Some(b) => Some(RefMut { _value: unsafe { &mut *self.value.get() }, _borrow: b }),
@ -317,7 +317,7 @@ impl<T> RefCell<T> {
/// # Panics
///
/// Panics if the value is currently borrowed.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn borrow_mut<'a>(&'a self) -> RefMut<'a, T> {
match self.try_borrow_mut() {
Some(ptr) => ptr,
@ -331,31 +331,31 @@ impl<T> RefCell<T> {
///
/// This function is `unsafe` because `UnsafeCell`'s field is public.
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
&self.value
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe impl<T> Send for RefCell<T> where T: Send {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Clone> Clone for RefCell<T> {
fn clone(&self) -> RefCell<T> {
RefCell::new(self.borrow().clone())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T:Default> Default for RefCell<T> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> RefCell<T> {
RefCell::new(Default::default())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: PartialEq> PartialEq for RefCell<T> {
fn eq(&self, other: &RefCell<T>) -> bool {
*self.borrow() == *other.borrow()
@ -399,7 +399,7 @@ impl<'b> Clone for BorrowRef<'b> {
}
/// Wraps a borrowed reference to a value in a `RefCell` box.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Ref<'b, T:'b> {
// FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref
@ -407,7 +407,7 @@ pub struct Ref<'b, T:'b> {
_borrow: BorrowRef<'b>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'b, T> Deref for Ref<'b, T> {
type Target = T;
@ -423,7 +423,8 @@ impl<'b, T> Deref for Ref<'b, T> {
///
/// A `Clone` implementation would interfere with the widespread
/// use of `r.borrow().clone()` to clone the contents of a `RefCell`.
#[unstable = "likely to be moved to a method, pending language changes"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to be moved to a method, pending language changes")]
pub fn clone_ref<'b, T:Clone>(orig: &Ref<'b, T>) -> Ref<'b, T> {
Ref {
_value: orig._value,
@ -457,7 +458,7 @@ impl<'b> BorrowRefMut<'b> {
}
/// Wraps a mutable borrowed reference to a value in a `RefCell` box.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct RefMut<'b, T:'b> {
// FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref
@ -465,7 +466,7 @@ pub struct RefMut<'b, T:'b> {
_borrow: BorrowRefMut<'b>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'b, T> Deref for RefMut<'b, T> {
type Target = T;
@ -475,7 +476,7 @@ impl<'b, T> Deref for RefMut<'b, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'b, T> DerefMut for RefMut<'b, T> {
#[inline]
fn deref_mut<'a>(&'a mut self) -> &'a mut T {
@ -521,13 +522,13 @@ impl<'b, T> DerefMut for RefMut<'b, T> {
/// is not recommended to access its fields directly, `get` should be used
/// instead.
#[lang="unsafe"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct UnsafeCell<T> {
/// Wrapped value
///
/// This field should not be accessed directly, it is made public for static
/// initializers.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub value: T,
}
@ -537,14 +538,14 @@ impl<T> UnsafeCell<T> {
///
/// All access to the inner value through methods is `unsafe`, and it is
/// highly discouraged to access the fields directly.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn new(value: T) -> UnsafeCell<T> {
UnsafeCell { value: value }
}
/// Gets a mutable pointer to the wrapped value.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn get(&self) -> *mut T { &self.value as *const T as *mut T }
/// Unwraps the value
@ -552,6 +553,6 @@ impl<T> UnsafeCell<T> {
/// This function is unsafe because there is no guarantee that this or other
/// tasks are currently inspecting the inner value.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn into_inner(self) -> T { self.value }
}

60
src/libcore/char.rs
View File

@ -64,12 +64,12 @@ static MAX_THREE_B: u32 = 0x10000u32;
*/
/// The highest valid code point
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MAX: char = '\u{10ffff}';
/// Converts from `u32` to a `char`
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn from_u32(i: u32) -> Option<char> {
// catch out-of-bounds and surrogates
if (i > MAX as u32) || (i >= 0xD800 && i <= 0xDFFF) {
@ -92,7 +92,7 @@ pub fn from_u32(i: u32) -> Option<char> {
/// Panics if given an `radix` > 36.
///
#[inline]
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub fn from_digit(num: uint, radix: uint) -> Option<char> {
if radix > 36 {
panic!("from_digit: radix is too high (maximum 36)");
@ -111,7 +111,7 @@ pub fn from_digit(num: uint, radix: uint) -> Option<char> {
}
/// Basic `char` manipulations.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait CharExt {
/// Checks if a `char` parses as a numeric digit in the given radix.
///
@ -126,7 +126,8 @@ pub trait CharExt {
/// # Panics
///
/// Panics if given a radix > 36.
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
fn is_digit(self, radix: uint) -> bool;
/// Converts a character to the corresponding digit.
@ -140,7 +141,8 @@ pub trait CharExt {
/// # Panics
///
/// Panics if given a radix outside the range [0..36].
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
fn to_digit(self, radix: uint) -> Option<uint>;
/// Returns an iterator that yields the hexadecimal Unicode escape
@ -149,7 +151,7 @@ pub trait CharExt {
/// All characters are escaped with Rust syntax of the form `\\u{NNNN}`
/// where `NNNN` is the shortest hexadecimal representation of the code
/// point.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn escape_unicode(self) -> EscapeUnicode;
/// Returns an iterator that yields the 'default' ASCII and
@ -164,17 +166,17 @@ pub trait CharExt {
/// escaped.
/// * Any other chars in the range [0x20,0x7e] are not escaped.
/// * Any other chars are given hex Unicode escapes; see `escape_unicode`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn escape_default(self) -> EscapeDefault;
/// Returns the amount of bytes this character would need if encoded in
/// UTF-8.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn len_utf8(self) -> uint;
/// Returns the amount of bytes this character would need if encoded in
/// UTF-16.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn len_utf16(self) -> uint;
/// Encodes this character as UTF-8 into the provided byte buffer,
@ -182,7 +184,7 @@ pub trait CharExt {
///
/// If the buffer is not large enough, nothing will be written into it
/// and a `None` will be returned.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn encode_utf8(self, dst: &mut [u8]) -> Option<uint>;
/// Encodes this character as UTF-16 into the provided `u16` buffer,
@ -190,18 +192,20 @@ pub trait CharExt {
///
/// If the buffer is not large enough, nothing will be written into it
/// and a `None` will be returned.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn encode_utf16(self, dst: &mut [u16]) -> Option<uint>;
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl CharExt for char {
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
fn is_digit(self, radix: uint) -> bool {
self.to_digit(radix).is_some()
}
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
fn to_digit(self, radix: uint) -> Option<uint> {
if radix > 36 {
panic!("to_digit: radix is too high (maximum 36)");
@ -216,12 +220,12 @@ impl CharExt for char {
else { None }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn escape_unicode(self) -> EscapeUnicode {
EscapeUnicode { c: self, state: EscapeUnicodeState::Backslash }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn escape_default(self) -> EscapeDefault {
let init_state = match self {
'\t' => EscapeDefaultState::Backslash('t'),
@ -237,7 +241,7 @@ impl CharExt for char {
}
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn len_utf8(self) -> uint {
let code = self as u32;
match () {
@ -249,14 +253,15 @@ impl CharExt for char {
}
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn len_utf16(self) -> uint {
let ch = self as u32;
if (ch & 0xFFFF_u32) == ch { 1 } else { 2 }
}
#[inline]
#[unstable = "pending decision about Iterator/Writer/Reader"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> {
// Marked #[inline] to allow llvm optimizing it away
let code = self as u32;
@ -284,7 +289,8 @@ impl CharExt for char {
}
#[inline]
#[unstable = "pending decision about Iterator/Writer/Reader"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> {
// Marked #[inline] to allow llvm optimizing it away
let mut ch = self as u32;
@ -307,14 +313,14 @@ impl CharExt for char {
/// An iterator over the characters that represent a `char`, as escaped by
/// Rust's unicode escaping rules.
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct EscapeUnicode {
c: char,
state: EscapeUnicodeState
}
#[derive(Clone)]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
enum EscapeUnicodeState {
Backslash,
Type,
@ -324,7 +330,7 @@ enum EscapeUnicodeState {
Done,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Iterator for EscapeUnicode {
type Item = char;
@ -370,13 +376,13 @@ impl Iterator for EscapeUnicode {
/// An iterator over the characters that represent a `char`, escaped
/// for maximum portability.
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct EscapeDefault {
state: EscapeDefaultState
}
#[derive(Clone)]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
enum EscapeDefaultState {
Backslash(char),
Char(char),
@ -384,7 +390,7 @@ enum EscapeDefaultState {
Unicode(EscapeUnicode),
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Iterator for EscapeDefault {
type Item = char;

16
src/libcore/clone.rs
View File

@ -19,15 +19,15 @@
//! explicitly, by convention implementing the `Clone` trait and calling
//! the `clone` method.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use marker::Sized;
/// A common trait for cloning an object.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Clone : Sized {
/// Returns a copy of the value.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn clone(&self) -> Self;
/// Perform copy-assignment from `source`.
@ -36,13 +36,14 @@ pub trait Clone : Sized {
/// but can be overridden to reuse the resources of `a` to avoid unnecessary
/// allocations.
#[inline(always)]
#[unstable = "this function is rarely used"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this function is rarely used")]
fn clone_from(&mut self, source: &Self) {
*self = source.clone()
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: ?Sized> Clone for &'a T {
/// Return a shallow copy of the reference.
#[inline]
@ -51,7 +52,7 @@ impl<'a, T: ?Sized> Clone for &'a T {
macro_rules! clone_impl {
($t:ty) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Clone for $t {
/// Return a deep copy of the value.
#[inline]
@ -81,7 +82,8 @@ clone_impl! { char }
macro_rules! extern_fn_clone {
($($A:ident),*) => (
#[unstable = "this may not be sufficient for fns with region parameters"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this may not be sufficient for fns with region parameters")]
impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType {
/// Return a copy of a function pointer
#[inline]

92
src/libcore/cmp.rs
View File

@ -39,7 +39,7 @@
//! assert!(SketchyNum {num: 25} != SketchyNum {num: 57});
//! ```
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use self::Ordering::*;
@ -68,16 +68,16 @@ use option::Option::{self, Some, None};
/// the rule that `eq` is a strict inverse of `ne`; that is, `!(a == b)` if and
/// only if `a != b`.
#[lang="eq"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[old_orphan_check]
pub trait PartialEq<Rhs: ?Sized = Self> {
/// This method tests for `self` and `other` values to be equal, and is used by `==`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn eq(&self, other: &Rhs) -> bool;
/// This method tests for `!=`.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn ne(&self, other: &Rhs) -> bool { !self.eq(other) }
}
@ -90,7 +90,7 @@ pub trait PartialEq<Rhs: ?Sized = Self> {
/// - reflexive: `a == a`;
/// - symmetric: `a == b` implies `b == a`; and
/// - transitive: `a == b` and `b == c` implies `a == c`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Eq: PartialEq<Self> {
// FIXME #13101: this method is used solely by #[deriving] to
// assert that every component of a type implements #[deriving]
@ -106,16 +106,16 @@ pub trait Eq: PartialEq<Self> {
/// An ordering is, e.g, a result of a comparison between two values.
#[derive(Clone, Copy, PartialEq, Show)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub enum Ordering {
/// An ordering where a compared value is less [than another].
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
Less = -1i,
/// An ordering where a compared value is equal [to another].
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
Equal = 0i,
/// An ordering where a compared value is greater [than another].
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
Greater = 1i,
}
@ -141,7 +141,7 @@ impl Ordering {
/// assert!(data == b);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn reverse(self) -> Ordering {
unsafe {
// this compiles really nicely (to a single instruction);
@ -164,7 +164,7 @@ impl Ordering {
/// true; and
/// - transitive, `a < b` and `b < c` implies `a < c`. The same must hold for
/// both `==` and `>`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Ord: Eq + PartialOrd<Self> {
/// This method returns an ordering between `self` and `other` values.
///
@ -178,26 +178,26 @@ pub trait Ord: Eq + PartialOrd<Self> {
/// assert_eq!(10u.cmp(&5), Greater); // because 10 > 5
/// assert_eq!( 5u.cmp(&5), Equal); // because 5 == 5
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn cmp(&self, other: &Self) -> Ordering;
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Eq for Ordering {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Ord for Ordering {
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn cmp(&self, other: &Ordering) -> Ordering {
(*self as int).cmp(&(*other as int))
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialOrd for Ordering {
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn partial_cmp(&self, other: &Ordering) -> Option<Ordering> {
(*self as int).partial_cmp(&(*other as int))
}
@ -224,16 +224,16 @@ impl PartialOrd for Ordering {
/// `NaN < 0 == false` and `NaN >= 0 == false` (cf. IEEE 754-2008 section
/// 5.11).
#[lang="ord"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
/// This method returns an ordering between `self` and `other` values
/// if one exists.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;
/// This method tests less than (for `self` and `other`) and is used by the `<` operator.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn lt(&self, other: &Rhs) -> bool {
match self.partial_cmp(other) {
Some(Less) => true,
@ -243,7 +243,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
/// This method tests less than or equal to (`<=`).
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn le(&self, other: &Rhs) -> bool {
match self.partial_cmp(other) {
Some(Less) | Some(Equal) => true,
@ -253,7 +253,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
/// This method tests greater than (`>`).
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn gt(&self, other: &Rhs) -> bool {
match self.partial_cmp(other) {
Some(Greater) => true,
@ -263,7 +263,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
/// This method tests greater than or equal to (`>=`).
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn ge(&self, other: &Rhs) -> bool {
match self.partial_cmp(other) {
Some(Greater) | Some(Equal) => true,
@ -274,14 +274,14 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
/// Compare and return the minimum of two values.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn min<T: Ord>(v1: T, v2: T) -> T {
if v1 < v2 { v1 } else { v2 }
}
/// Compare and return the maximum of two values.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn max<T: Ord>(v1: T, v2: T) -> T {
if v1 > v2 { v1 } else { v2 }
}
@ -290,7 +290,7 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
///
/// Returns the first argument if the comparison determines them to be equal.
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
match v1.partial_cmp(&v2) {
Some(Less) | Some(Equal) => Some(v1),
@ -303,7 +303,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
///
/// Returns the first argument if the comparison determines them to be equal.
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
match v1.partial_cmp(&v2) {
Some(Less) => Some(v2),
@ -322,7 +322,7 @@ mod impls {
macro_rules! partial_eq_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialEq for $t {
#[inline]
fn eq(&self, other: &$t) -> bool { (*self) == (*other) }
@ -332,7 +332,7 @@ mod impls {
)*)
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialEq for () {
#[inline]
fn eq(&self, _other: &()) -> bool { true }
@ -346,7 +346,7 @@ mod impls {
macro_rules! eq_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Eq for $t {}
)*)
}
@ -355,7 +355,7 @@ mod impls {
macro_rules! partial_ord_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialOrd for $t {
#[inline]
fn partial_cmp(&self, other: &$t) -> Option<Ordering> {
@ -378,7 +378,7 @@ mod impls {
)*)
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialOrd for () {
#[inline]
fn partial_cmp(&self, _: &()) -> Option<Ordering> {
@ -386,7 +386,7 @@ mod impls {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialOrd for bool {
#[inline]
fn partial_cmp(&self, other: &bool) -> Option<Ordering> {
@ -398,7 +398,7 @@ mod impls {
macro_rules! ord_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Ord for $t {
#[inline]
fn cmp(&self, other: &$t) -> Ordering {
@ -410,13 +410,13 @@ mod impls {
)*)
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Ord for () {
#[inline]
fn cmp(&self, _other: &()) -> Ordering { Equal }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Ord for bool {
#[inline]
fn cmp(&self, other: &bool) -> Ordering {
@ -428,14 +428,14 @@ mod impls {
// & pointers
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b B> for &'a A where A: PartialEq<B> {
#[inline]
fn eq(&self, other: & &'b B) -> bool { PartialEq::eq(*self, *other) }
#[inline]
fn ne(&self, other: & &'b B) -> bool { PartialEq::ne(*self, *other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b B> for &'a A where A: PartialOrd<B> {
#[inline]
fn partial_cmp(&self, other: &&'b B) -> Option<Ordering> {
@ -450,24 +450,24 @@ mod impls {
#[inline]
fn gt(&self, other: & &'b B) -> bool { PartialOrd::gt(*self, *other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A: ?Sized> Ord for &'a A where A: Ord {
#[inline]
fn cmp(&self, other: & &'a A) -> Ordering { Ord::cmp(*self, *other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A: ?Sized> Eq for &'a A where A: Eq {}
// &mut pointers
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b mut B> for &'a mut A where A: PartialEq<B> {
#[inline]
fn eq(&self, other: &&'b mut B) -> bool { PartialEq::eq(*self, *other) }
#[inline]
fn ne(&self, other: &&'b mut B) -> bool { PartialEq::ne(*self, *other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b mut B> for &'a mut A where A: PartialOrd<B> {
#[inline]
fn partial_cmp(&self, other: &&'b mut B) -> Option<Ordering> {
@ -482,15 +482,15 @@ mod impls {
#[inline]
fn gt(&self, other: &&'b mut B) -> bool { PartialOrd::gt(*self, *other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A: ?Sized> Ord for &'a mut A where A: Ord {
#[inline]
fn cmp(&self, other: &&'a mut A) -> Ordering { Ord::cmp(*self, *other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A: ?Sized> Eq for &'a mut A where A: Eq {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b mut B> for &'a A where A: PartialEq<B> {
#[inline]
fn eq(&self, other: &&'b mut B) -> bool { PartialEq::eq(*self, *other) }
@ -498,7 +498,7 @@ mod impls {
fn ne(&self, other: &&'b mut B) -> bool { PartialEq::ne(*self, *other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b B> for &'a mut A where A: PartialEq<B> {
#[inline]
fn eq(&self, other: &&'b B) -> bool { PartialEq::eq(*self, *other) }

10
src/libcore/default.rs
View File

@ -81,7 +81,7 @@
//! }
//! ```
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
/// A trait that types which have a useful default value should implement.
///
@ -97,7 +97,7 @@
/// bar: f32,
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Default {
/// Returns the "default value" for a type.
///
@ -131,16 +131,16 @@ pub trait Default {
/// fn default() -> Kind { Kind::A }
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> Self;
}
macro_rules! default_impl {
($t:ty, $v:expr) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Default for $t {
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> $t { $v }
}
}

9
src/libcore/finally.rs
View File

@ -30,10 +30,11 @@
//! })
//! ```
#![deprecated = "It is unclear if this module is more robust than implementing \
Drop on a custom type, and this module is being removed with no \
replacement. Use a custom Drop implementation to regain existing \
functionality."]
#![deprecated(feature = "unnamed_feature", since = "1.0.0",
reason = "It is unclear if this module is more robust than implementing \
Drop on a custom type, and this module is being removed with no \
replacement. Use a custom Drop implementation to regain existing \
functionality.")]
#![allow(deprecated)]
use ops::{Drop, FnMut, FnOnce};

100
src/libcore/fmt/mod.rs
View File

@ -11,7 +11,7 @@
//! Utilities for formatting and printing strings
#![allow(unused_variables)]
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use any;
use cell::{Cell, RefCell, Ref, RefMut};
@ -36,7 +36,8 @@ mod num;
mod float;
pub mod rt;
#[unstable = "core and I/O reconciliation may alter this definition"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "core and I/O reconciliation may alter this definition")]
/// The type returned by formatter methods.
pub type Result = result::Result<(), Error>;
@ -45,7 +46,8 @@ pub type Result = result::Result<(), Error>;
/// This type does not support transmission of an error other than that an error
/// occurred. Any extra information must be arranged to be transmitted through
/// some other means.
#[unstable = "core and I/O reconciliation may alter this definition"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "core and I/O reconciliation may alter this definition")]
#[derive(Copy)]
pub struct Error;
@ -58,7 +60,8 @@ pub struct Error;
/// This trait should generally not be implemented by consumers of the standard
/// library. The `write!` macro accepts an instance of `io::Writer`, and the
/// `io::Writer` trait is favored over implementing this trait.
#[unstable = "waiting for core and I/O reconciliation"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "waiting for core and I/O reconciliation")]
pub trait Writer {
/// Writes a slice of bytes into this writer, returning whether the write
/// succeeded.
@ -101,7 +104,8 @@ pub trait Writer {
/// A struct to represent both where to emit formatting strings to and how they
/// should be formatted. A mutable version of this is passed to all formatting
/// traits.
#[unstable = "name may change and implemented traits are also unstable"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "name may change and implemented traits are also unstable")]
pub struct Formatter<'a> {
flags: uint,
fill: char,
@ -123,7 +127,8 @@ enum Void {}
/// family of functions. It contains a function to format the given value. At
/// compile time it is ensured that the function and the value have the correct
/// types, and then this struct is used to canonicalize arguments to one type.
#[unstable = "implementation detail of the `format_args!` macro"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "implementation detail of the `format_args!` macro")]
#[derive(Copy)]
pub struct Argument<'a> {
value: &'a Void,
@ -162,7 +167,8 @@ impl<'a> Arguments<'a> {
/// When using the format_args!() macro, this function is used to generate the
/// Arguments structure.
#[doc(hidden)] #[inline]
#[unstable = "implementation detail of the `format_args!` macro"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "implementation detail of the `format_args!` macro")]
pub fn new(pieces: &'a [&'a str],
args: &'a [Argument<'a>]) -> Arguments<'a> {
Arguments {
@ -179,7 +185,8 @@ impl<'a> Arguments<'a> {
/// created with `argumentuint`. However, failing to do so doesn't cause
/// unsafety, but will ignore invalid .
#[doc(hidden)] #[inline]
#[unstable = "implementation detail of the `format_args!` macro"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "implementation detail of the `format_args!` macro")]
pub fn with_placeholders(pieces: &'a [&'a str],
fmt: &'a [rt::Argument],
args: &'a [Argument<'a>]) -> Arguments<'a> {
@ -200,7 +207,7 @@ impl<'a> Arguments<'a> {
/// and pass it to a function or closure, passed as the first argument. The
/// macro validates the format string at compile-time so usage of the `write`
/// and `format` functions can be safely performed.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[derive(Copy)]
pub struct Arguments<'a> {
// Format string pieces to print.
@ -220,7 +227,7 @@ impl<'a> Show for Arguments<'a> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> String for Arguments<'a> {
fn fmt(&self, fmt: &mut Formatter) -> Result {
write(fmt.buf, *self)
@ -229,7 +236,8 @@ impl<'a> String for Arguments<'a> {
/// Format trait for the `:?` format. Useful for debugging, most all types
/// should implement this.
#[unstable = "I/O and core have yet to be reconciled"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "I/O and core have yet to be reconciled")]
pub trait Show {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
@ -237,7 +245,8 @@ pub trait Show {
/// When a value can be semantically expressed as a String, this trait may be
/// used. It corresponds to the default format, `{}`.
#[unstable = "I/O and core have yet to be reconciled"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "I/O and core have yet to be reconciled")]
pub trait String {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
@ -245,49 +254,56 @@ pub trait String {
/// Format trait for the `o` character
#[unstable = "I/O and core have yet to be reconciled"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "I/O and core have yet to be reconciled")]
pub trait Octal {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
/// Format trait for the `b` character
#[unstable = "I/O and core have yet to be reconciled"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "I/O and core have yet to be reconciled")]
pub trait Binary {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
/// Format trait for the `x` character
#[unstable = "I/O and core have yet to be reconciled"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "I/O and core have yet to be reconciled")]
pub trait LowerHex {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
/// Format trait for the `X` character
#[unstable = "I/O and core have yet to be reconciled"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "I/O and core have yet to be reconciled")]
pub trait UpperHex {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
/// Format trait for the `p` character
#[unstable = "I/O and core have yet to be reconciled"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "I/O and core have yet to be reconciled")]
pub trait Pointer {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
/// Format trait for the `e` character
#[unstable = "I/O and core have yet to be reconciled"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "I/O and core have yet to be reconciled")]
pub trait LowerExp {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
/// Format trait for the `E` character
#[unstable = "I/O and core have yet to be reconciled"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "I/O and core have yet to be reconciled")]
pub trait UpperExp {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
@ -301,8 +317,9 @@ pub trait UpperExp {
///
/// * output - the buffer to write output to
/// * args - the precompiled arguments generated by `format_args!`
#[unstable = "libcore and I/O have yet to be reconciled, and this is an \
implementation detail which should not otherwise be exported"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "libcore and I/O have yet to be reconciled, and this is an \
implementation detail which should not otherwise be exported")]
pub fn write(output: &mut Writer, args: Arguments) -> Result {
let mut formatter = Formatter {
flags: 0,
@ -398,7 +415,8 @@ impl<'a> Formatter<'a> {
///
/// This function will correctly account for the flags provided as well as
/// the minimum width. It will not take precision into account.
#[unstable = "definition may change slightly over time"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "definition may change slightly over time")]
pub fn pad_integral(&mut self,
is_positive: bool,
prefix: &str,
@ -474,7 +492,8 @@ impl<'a> Formatter<'a> {
/// is longer than this length
///
/// Notably this function ignored the `flag` parameters
#[unstable = "definition may change slightly over time"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "definition may change slightly over time")]
pub fn pad(&mut self, s: &str) -> Result {
// Make sure there's a fast path up front
if self.width.is_none() && self.precision.is_none() {
@ -551,35 +570,38 @@ impl<'a> Formatter<'a> {
/// Writes some data to the underlying buffer contained within this
/// formatter.
#[unstable = "reconciling core and I/O may alter this definition"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "reconciling core and I/O may alter this definition")]
pub fn write_str(&mut self, data: &str) -> Result {
self.buf.write_str(data)
}
/// Writes some formatted information into this instance
#[unstable = "reconciling core and I/O may alter this definition"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "reconciling core and I/O may alter this definition")]
pub fn write_fmt(&mut self, fmt: Arguments) -> Result {
write(self.buf, fmt)
}
/// Flags for formatting (packed version of rt::Flag)
#[unstable = "return type may change and method was just created"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "return type may change and method was just created")]
pub fn flags(&self) -> uint { self.flags }
/// Character used as 'fill' whenever there is alignment
#[unstable = "method was just created"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "method was just created")]
pub fn fill(&self) -> char { self.fill }
/// Flag indicating what form of alignment was requested
#[unstable = "method was just created"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "method was just created")]
pub fn align(&self) -> rt::Alignment { self.align }
/// Optionally specified integer width that the output should be
#[unstable = "method was just created"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "method was just created")]
pub fn width(&self) -> Option<uint> { self.width }
/// Optionally specified precision for numeric types
#[unstable = "method was just created"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "method was just created")]
pub fn precision(&self) -> Option<uint> { self.precision }
}
@ -592,7 +614,8 @@ impl Show for Error {
/// This is a function which calls are emitted to by the compiler itself to
/// create the Argument structures that are passed into the `format` function.
#[doc(hidden)] #[inline]
#[unstable = "implementation detail of the `format_args!` macro"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "implementation detail of the `format_args!` macro")]
pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
t: &'a T) -> Argument<'a> {
Argument::new(t, f)
@ -601,7 +624,8 @@ pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
/// When the compiler determines that the type of an argument *must* be a uint
/// (such as for width and precision), then it invokes this method.
#[doc(hidden)] #[inline]
#[unstable = "implementation detail of the `format_args!` macro"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "implementation detail of the `format_args!` macro")]
pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
Argument::from_uint(s)
}
@ -629,7 +653,7 @@ impl Show for bool {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl String for bool {
fn fmt(&self, f: &mut Formatter) -> Result {
String::fmt(if *self { "true" } else { "false" }, f)
@ -646,7 +670,7 @@ impl Show for str {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl String for str {
fn fmt(&self, f: &mut Formatter) -> Result {
f.pad(self)
@ -664,7 +688,7 @@ impl Show for char {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl String for char {
fn fmt(&self, f: &mut Formatter) -> Result {
let mut utf8 = [0u8; 4];
@ -710,7 +734,7 @@ macro_rules! floating { ($ty:ident) => {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl String for $ty {
fn fmt(&self, fmt: &mut Formatter) -> Result {
use num::Float;
@ -855,7 +879,7 @@ impl<T: Copy + Show> Show for Cell<T> {
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<T: Show> Show for RefCell<T> {
fn fmt(&self, f: &mut Formatter) -> Result {
match self.try_borrow() {
@ -877,7 +901,7 @@ impl<'b, T: Show> Show for RefMut<'b, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl String for Utf8Error {
fn fmt(&self, f: &mut Formatter) -> Result {
match *self {

9
src/libcore/fmt/num.rs
View File

@ -111,7 +111,8 @@ radix! { UpperHex, 16, "0x", x @ 0 ... 9 => b'0' + x,
/// A radix with in the range of `2..36`.
#[derive(Clone, Copy, PartialEq)]
#[unstable = "may be renamed or move to a different module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "may be renamed or move to a different module")]
pub struct Radix {
base: u8,
}
@ -135,7 +136,8 @@ impl GenericRadix for Radix {
}
/// A helper type for formatting radixes.
#[unstable = "may be renamed or move to a different module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "may be renamed or move to a different module")]
#[derive(Copy)]
pub struct RadixFmt<T, R>(T, R);
@ -147,7 +149,8 @@ pub struct RadixFmt<T, R>(T, R);
/// use std::fmt::radix;
/// assert_eq!(format!("{}", radix(55i, 36)), "1j".to_string());
/// ```
#[unstable = "may be renamed or move to a different module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "may be renamed or move to a different module")]
pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
RadixFmt(x, Radix::new(base))
}

3
src/libcore/fmt/rt.rs
View File

@ -14,7 +14,8 @@
//! These definitions are similar to their `ct` equivalents, but differ in that
//! these can be statically allocated and are slightly optimized for the runtime
#![unstable = "implementation detail of the `format_args!` macro"]
#![unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "implementation detail of the `format_args!` macro")]
pub use self::Alignment::*;
pub use self::Count::*;

3
src/libcore/hash/mod.rs
View File

@ -56,7 +56,8 @@
//! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2));
//! ```
#![unstable = "module was recently redesigned"]
#![unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "module was recently redesigned")]
use prelude::*;

2
src/libcore/hash/sip.rs
View File

@ -112,7 +112,7 @@ impl SipHasher {
}
/// Returns the computed hash.
#[deprecated = "renamed to finish"]
#[deprecated(feature = "oldstuff", since = "1.0.0", reason = "renamed to finish")]
pub fn result(&self) -> u64 { self.finish() }
}

13
src/libcore/intrinsics.rs
View File

@ -39,7 +39,7 @@
//! guaranteed to happen in order. This is the standard mode for working
//! with atomic types and is equivalent to Java's `volatile`.
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![allow(missing_docs)]
use marker::Sized;
@ -227,7 +227,7 @@ extern "rust-intrinsic" {
///
/// `forget` is unsafe because the caller is responsible for
/// ensuring the argument is deallocated already.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn forget<T>(_: T) -> ();
/// Unsafely transforms a value of one type into a value of another type.
@ -243,7 +243,7 @@ extern "rust-intrinsic" {
/// let v: &[u8] = unsafe { mem::transmute("L") };
/// assert!(v == [76u8]);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn transmute<T,U>(e: T) -> U;
/// Gives the address for the return value of the enclosing function.
@ -303,7 +303,7 @@ extern "rust-intrinsic" {
/// }
/// }
/// ```
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint);
/// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
@ -333,12 +333,13 @@ extern "rust-intrinsic" {
/// }
/// ```
///
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint);
/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
/// bytes of memory starting at `dst` to `c`.
#[unstable = "uncertain about naming and semantics"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "uncertain about naming and semantics")]
pub fn set_memory<T>(dst: *mut T, val: u8, count: uint);
/// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with

355
src/libcore/iter.rs
View File

File diff suppressed because it is too large Load Diff

2
src/libcore/lib.rs
View File

@ -48,7 +48,7 @@
// separate crate, libcoretest, to avoid bizarre issues.
#![crate_name = "core"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "rlib"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",

14
src/libcore/macros.rs
View File

@ -52,7 +52,7 @@ macro_rules! panic {
/// assert!(a + b == 30, "a = {}, b = {}", a, b);
/// ```
#[macro_export]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
macro_rules! assert {
($cond:expr) => (
if !$cond {
@ -79,7 +79,7 @@ macro_rules! assert {
/// assert_eq!(a, b);
/// ```
#[macro_export]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
macro_rules! assert_eq {
($left:expr , $right:expr) => ({
match (&($left), &($right)) {
@ -123,7 +123,7 @@ macro_rules! assert_eq {
/// debug_assert!(a + b == 30, "a = {}, b = {}", a, b);
/// ```
#[macro_export]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
macro_rules! debug_assert {
($($arg:tt)*) => (if cfg!(not(ndebug)) { assert!($($arg)*); })
}
@ -185,7 +185,7 @@ macro_rules! write {
/// Equivalent to the `write!` macro, except that a newline is appended after
/// the message is written.
#[macro_export]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
macro_rules! writeln {
($dst:expr, $fmt:expr) => (
write!($dst, concat!($fmt, "\n"))
@ -235,7 +235,8 @@ macro_rules! writeln {
/// }
/// ```
#[macro_export]
#[unstable = "relationship with panic is unclear"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "relationship with panic is unclear")]
macro_rules! unreachable {
() => ({
panic!("internal error: entered unreachable code")
@ -251,7 +252,8 @@ macro_rules! unreachable {
/// A standardised placeholder for marking unfinished code. It panics with the
/// message `"not yet implemented"` when executed.
#[macro_export]
#[unstable = "relationship with panic is unclear"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "relationship with panic is unclear")]
macro_rules! unimplemented {
() => (panic!("not yet implemented"))
}

48
src/libcore/marker.rs
View File

@ -23,19 +23,20 @@
//! implemented using unsafe code. In that case, you may want to embed
//! some of the marker types below into your type.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use clone::Clone;
/// Types able to be transferred across task boundaries.
#[unstable = "will be overhauled with new lifetime rules; see RFC 458"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will be overhauled with new lifetime rules; see RFC 458")]
#[lang="send"]
pub unsafe trait Send: 'static {
// empty.
}
/// Types with a constant size known at compile-time.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[lang="sized"]
pub trait Sized {
// Empty.
@ -140,7 +141,7 @@ pub trait Sized {
/// to consider though: if you think your type may _not_ be able to implement `Copy` in the future,
/// then it might be prudent to not implement `Copy`. This is because removing `Copy` is a breaking
/// change: that second example would fail to compile if we made `Foo` non-`Copy`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[lang="copy"]
pub trait Copy {
// Empty.
@ -191,7 +192,8 @@ pub trait Copy {
/// around the value(s) which can be mutated when behind a `&`
/// reference; not doing this is undefined behaviour (for example,
/// `transmute`-ing from `&T` to `&mut T` is illegal).
#[unstable = "will be overhauled with new lifetime rules; see RFC 458"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will be overhauled with new lifetime rules; see RFC 458")]
#[lang="sync"]
pub unsafe trait Sync {
// Empty
@ -235,7 +237,8 @@ pub unsafe trait Sync {
/// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U`
/// (for example, `S<&'static int>` is a subtype of `S<&'a int>`
/// for some lifetime `'a`, but not the other way around).
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="covariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct CovariantType<T: ?Sized>;
@ -284,7 +287,8 @@ impl<T: ?Sized> Clone for CovariantType<T> {
/// subtype of `S<U>` if `U` is a subtype of `T`; given that the
/// function requires arguments of type `T`, it must also accept
/// arguments of type `U`, hence such a conversion is safe.
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="contravariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct ContravariantType<T: ?Sized>;
@ -314,14 +318,17 @@ impl<T: ?Sized> Clone for ContravariantType<T> {
/// The type system would infer that `value` is only read here and
/// never written, but in fact `Cell` uses unsafe code to achieve
/// interior mutability.
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="invariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct InvariantType<T: ?Sized>;
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
impl<T: ?Sized> Copy for InvariantType<T> {}
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
impl<T: ?Sized> Clone for InvariantType<T> {
fn clone(&self) -> InvariantType<T> { *self }
}
@ -342,7 +349,8 @@ impl<T: ?Sized> Clone for InvariantType<T> {
///
/// For more information about variance, refer to this Wikipedia
/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="covariant_lifetime"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct CovariantLifetime<'a>;
@ -359,7 +367,8 @@ pub struct CovariantLifetime<'a>;
///
/// For more information about variance, refer to this Wikipedia
/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="contravariant_lifetime"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct ContravariantLifetime<'a>;
@ -371,7 +380,8 @@ pub struct ContravariantLifetime<'a>;
/// pointer that is actually a pointer into memory with lifetime `'a`,
/// and this pointer is itself stored in an inherently mutable
/// location (such as a `Cell`).
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="invariant_lifetime"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct InvariantLifetime<'a>;
@ -380,7 +390,8 @@ pub struct InvariantLifetime<'a>;
/// be safely sent between tasks, even if it is owned. This is
/// typically embedded in other types, such as `Gc`, to ensure that
/// their instances remain thread-local.
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="no_send_bound"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
#[cfg(stage0)] // NOTE remove impl after next snapshot
@ -389,7 +400,8 @@ pub struct NoSend;
/// A type which is considered "not POD", meaning that it is not
/// implicitly copyable. This is typically embedded in other types to
/// ensure that they are never copied, even if they lack a destructor.
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="no_copy_bound"]
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
#[allow(missing_copy_implementations)]
@ -398,7 +410,8 @@ pub struct NoCopy;
/// A type which is considered "not sync", meaning that
/// its contents are not threadsafe, hence they cannot be
/// shared between tasks.
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="no_sync_bound"]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
#[cfg(stage0)] // NOTE remove impl after next snapshot
@ -406,7 +419,8 @@ pub struct NoSync;
/// A type which is considered managed by the GC. This is typically
/// embedded in other types.
#[unstable = "likely to change with new variance strategy"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "likely to change with new variance strategy")]
#[lang="managed_bound"]
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
#[allow(missing_copy_implementations)]

40
src/libcore/mem.rs
View File

@ -13,13 +13,13 @@
//! This module contains functions for querying the size and alignment of
//! types, initializing and manipulating memory.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use marker::Sized;
use intrinsics;
use ptr;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub use intrinsics::transmute;
/// Moves a thing into the void.
@ -29,7 +29,7 @@ pub use intrinsics::transmute;
///
/// This function is the unsafe version of the `drop` function because it does
/// not run any destructors.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub use intrinsics::forget;
/// Returns the size of a type in bytes.
@ -42,7 +42,7 @@ pub use intrinsics::forget;
/// assert_eq!(4, mem::size_of::<i32>());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn size_of<T>() -> uint {
unsafe { intrinsics::size_of::<T>() }
}
@ -57,7 +57,7 @@ pub fn size_of<T>() -> uint {
/// assert_eq!(4, mem::size_of_val(&5i32));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn size_of_val<T>(_val: &T) -> uint {
size_of::<T>()
}
@ -74,7 +74,7 @@ pub fn size_of_val<T>(_val: &T) -> uint {
/// assert_eq!(4, mem::min_align_of::<i32>());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn min_align_of<T>() -> uint {
unsafe { intrinsics::min_align_of::<T>() }
}
@ -89,7 +89,7 @@ pub fn min_align_of<T>() -> uint {
/// assert_eq!(4, mem::min_align_of_val(&5i32));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn min_align_of_val<T>(_val: &T) -> uint {
min_align_of::<T>()
}
@ -107,7 +107,7 @@ pub fn min_align_of_val<T>(_val: &T) -> uint {
/// assert_eq!(4, mem::align_of::<i32>());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn align_of<T>() -> uint {
// We use the preferred alignment as the default alignment for a type. This
// appears to be what clang migrated towards as well:
@ -129,7 +129,7 @@ pub fn align_of<T>() -> uint {
/// assert_eq!(4, mem::align_of_val(&5i32));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn align_of_val<T>(_val: &T) -> uint {
align_of::<T>()
}
@ -153,7 +153,7 @@ pub fn align_of_val<T>(_val: &T) -> uint {
/// let x: int = unsafe { mem::zeroed() };
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn zeroed<T>() -> T {
intrinsics::init()
}
@ -174,7 +174,7 @@ pub unsafe fn zeroed<T>() -> T {
/// let x: int = unsafe { mem::uninitialized() };
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn uninitialized<T>() -> T {
intrinsics::uninit()
}
@ -196,7 +196,7 @@ pub unsafe fn uninitialized<T>() -> T {
/// assert_eq!(5i, *y);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn swap<T>(x: &mut T, y: &mut T) {
unsafe {
// Give ourselves some scratch space to work with
@ -261,7 +261,7 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
/// }
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn replace<T>(dest: &mut T, mut src: T) -> T {
swap(dest, &mut src);
src
@ -288,7 +288,7 @@ pub fn replace<T>(dest: &mut T, mut src: T) -> T {
/// println!("{}", *borrow);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn drop<T>(_x: T) { }
/// Interprets `src` as `&U`, and then reads `src` without moving the contained value.
@ -311,15 +311,16 @@ pub fn drop<T>(_x: T) { }
/// assert_eq!(1u, one);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
ptr::read(src as *const T as *const U)
}
/// Transforms lifetime of the second pointer to match the first.
#[inline]
#[unstable = "this function may be removed in the future due to its \
questionable utility"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this function may be removed in the future due to its \
questionable utility")]
pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
ptr: &T) -> &'a T {
transmute(ptr)
@ -327,8 +328,9 @@ pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
/// Transforms lifetime of the second mutable pointer to match the first.
#[inline]
#[unstable = "this function may be removed in the future due to its \
questionable utility"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "this function may be removed in the future due to its \
questionable utility")]
pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S,
ptr: &mut T)
-> &'a mut T {

2
src/libcore/nonzero.rs
View File

@ -32,7 +32,7 @@ unsafe impl Zeroable for u64 {}
/// NULL or 0 that might allow certain optimizations.
#[lang="non_zero"]
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Show)]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub struct NonZero<T: Zeroable>(T);
impl<T: Zeroable> NonZero<T> {

55
src/libcore/num/f32.rs
View File

@ -14,7 +14,7 @@
// FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353
#![allow(overflowing_literals)]
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use intrinsics;
use mem;
@ -22,46 +22,47 @@ use num::Float;
use num::FpCategory as Fp;
use option::Option;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const RADIX: uint = 2u;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const MANTISSA_DIGITS: uint = 24u;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const DIGITS: uint = 6u;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const EPSILON: f32 = 1.19209290e-07_f32;
/// Smallest finite f32 value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MIN_VALUE: f32 = -3.40282347e+38_f32;
/// Smallest positive, normalized f32 value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MIN_POS_VALUE: f32 = 1.17549435e-38_f32;
/// Largest finite f32 value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MAX_VALUE: f32 = 3.40282347e+38_f32;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const MIN_EXP: int = -125;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const MAX_EXP: int = 128;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const MIN_10_EXP: int = -37;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const MAX_10_EXP: int = 38;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const NAN: f32 = 0.0_f32/0.0_f32;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const INFINITY: f32 = 1.0_f32/0.0_f32;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32;
/// Various useful constants.
#[unstable = "naming scheme needs to be revisited"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "naming scheme needs to be revisited")]
pub mod consts {
// FIXME: replace with mathematical constants from cmath.
@ -117,7 +118,7 @@ pub mod consts {
pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32;
}
#[unstable = "trait is unstable"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")]
impl Float for f32 {
#[inline]
fn nan() -> f32 { NAN }
@ -177,43 +178,43 @@ impl Float for f32 {
}
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn mantissa_digits(_: Option<f32>) -> uint { MANTISSA_DIGITS }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn digits(_: Option<f32>) -> uint { DIGITS }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn epsilon() -> f32 { EPSILON }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn min_exp(_: Option<f32>) -> int { MIN_EXP }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn max_exp(_: Option<f32>) -> int { MAX_EXP }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn min_10_exp(_: Option<f32>) -> int { MIN_10_EXP }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn max_10_exp(_: Option<f32>) -> int { MAX_10_EXP }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn min_value() -> f32 { MIN_VALUE }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn min_pos_value(_: Option<f32>) -> f32 { MIN_POS_VALUE }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn max_value() -> f32 { MAX_VALUE }
/// Returns the mantissa, exponent and sign as integers.

53
src/libcore/num/f64.rs
View File

@ -14,7 +14,7 @@
// FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353
#![allow(overflowing_literals)]
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use intrinsics;
use mem;
@ -26,45 +26,46 @@ use option::Option;
// constants are implemented in favour of referencing the respective
// members of `Bounded` and `Float`.
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const RADIX: uint = 2u;
pub const MANTISSA_DIGITS: uint = 53u;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const DIGITS: uint = 15u;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const EPSILON: f64 = 2.2204460492503131e-16_f64;
/// Smallest finite f64 value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MIN_VALUE: f64 = -1.7976931348623157e+308_f64;
/// Smallest positive, normalized f64 value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MIN_POS_VALUE: f64 = 2.2250738585072014e-308_f64;
/// Largest finite f64 value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MAX_VALUE: f64 = 1.7976931348623157e+308_f64;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const MIN_EXP: int = -1021;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const MAX_EXP: int = 1024;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const MIN_10_EXP: int = -307;
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")]
pub const MAX_10_EXP: int = 308;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const NAN: f64 = 0.0_f64/0.0_f64;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const INFINITY: f64 = 1.0_f64/0.0_f64;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64;
/// Various useful constants.
#[unstable = "naming scheme needs to be revisited"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "naming scheme needs to be revisited")]
pub mod consts {
// FIXME: replace with mathematical constants from cmath.
@ -124,7 +125,7 @@ pub mod consts {
pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;
}
#[unstable = "trait is unstable"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")]
impl Float for f64 {
#[inline]
fn nan() -> f64 { NAN }
@ -184,43 +185,43 @@ impl Float for f64 {
}
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn mantissa_digits(_: Option<f64>) -> uint { MANTISSA_DIGITS }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn digits(_: Option<f64>) -> uint { DIGITS }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn epsilon() -> f64 { EPSILON }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn min_exp(_: Option<f64>) -> int { MIN_EXP }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn max_exp(_: Option<f64>) -> int { MAX_EXP }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn min_10_exp(_: Option<f64>) -> int { MIN_10_EXP }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn max_10_exp(_: Option<f64>) -> int { MAX_10_EXP }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn min_value() -> f64 { MIN_VALUE }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn min_pos_value(_: Option<f64>) -> f64 { MIN_POS_VALUE }
#[inline]
#[deprecated]
#[deprecated(feature = "oldstuff", since = "1.0.0")]
fn max_value() -> f64 { MAX_VALUE }
/// Returns the mantissa, exponent and sign as integers.

2
src/libcore/num/i16.rs
View File

@ -10,7 +10,7 @@
//! Operations and constants for signed 16-bits integers (`i16` type)
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "i16")]
int_module! { i16, 16 }

2
src/libcore/num/i32.rs
View File

@ -10,7 +10,7 @@
//! Operations and constants for signed 32-bits integers (`i32` type)
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "i32")]
int_module! { i32, 32 }

2
src/libcore/num/i64.rs
View File

@ -10,7 +10,7 @@
//! Operations and constants for signed 64-bits integers (`i64` type)
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "i64")]
int_module! { i64, 64 }

2
src/libcore/num/i8.rs
View File

@ -10,7 +10,7 @@
//! Operations and constants for signed 8-bits integers (`i8` type)
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "i8")]
int_module! { i8, 8 }

2
src/libcore/num/int.rs
View File

@ -14,7 +14,7 @@
//! alpha cycle along with the development of clearer conventions
//! around integer types.
#![deprecated = "replaced by isize"]
#![deprecated(feature = "oldstuff", since = "1.0.0", reason = "replaced by isize")]
#[cfg(target_pointer_width = "32")] int_module! { int, 32 }
#[cfg(target_pointer_width = "64")] int_module! { int, 64 }

8
src/libcore/num/int_macros.rs
View File

@ -14,21 +14,21 @@ macro_rules! int_module { ($T:ty, $bits:expr) => (
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
// calling the `mem::size_of` function.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub const BITS : uint = $bits;
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
// calling the `mem::size_of` function.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub const BYTES : uint = ($bits / 8);
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
// calling the `Bounded::min_value` function.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MIN: $T = (-1 as $T) << (BITS - 1);
// FIXME(#9837): Compute MIN like this so the high bits that shouldn't exist are 0.
// FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
// calling the `Bounded::max_value` function.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MAX: $T = !MIN;
) }

2
src/libcore/num/isize.rs
View File

@ -14,7 +14,7 @@
//! new type will gradually take place over the alpha cycle along with
//! the development of clearer conventions around integer types.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "isize")]
#[cfg(target_pointer_width = "32")]

178
src/libcore/num/mod.rs
View File

@ -12,7 +12,7 @@
//! Numeric traits and functions for the built-in numeric types.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![allow(missing_docs)]
use char::CharExt;
@ -30,7 +30,7 @@ use option::Option::{Some, None};
use str::{FromStr, StrExt};
/// A built-in signed or unsigned integer.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Int
: Copy + Clone
+ NumCast
@ -50,22 +50,26 @@ pub trait Int
{
/// Returns the `0` value of this integer type.
// FIXME (#5527): Should be an associated constant
#[unstable = "unsure about its place in the world"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "unsure about its place in the world")]
fn zero() -> Self;
/// Returns the `1` value of this integer type.
// FIXME (#5527): Should be an associated constant
#[unstable = "unsure about its place in the world"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "unsure about its place in the world")]
fn one() -> Self;
/// Returns the smallest value that can be represented by this integer type.
// FIXME (#5527): Should be and associated constant
#[unstable = "unsure about its place in the world"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "unsure about its place in the world")]
fn min_value() -> Self;
/// Returns the largest value that can be represented by this integer type.
// FIXME (#5527): Should be and associated constant
#[unstable = "unsure about its place in the world"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "unsure about its place in the world")]
fn max_value() -> Self;
/// Returns the number of ones in the binary representation of `self`.
@ -79,7 +83,8 @@ pub trait Int
///
/// assert_eq!(n.count_ones(), 3);
/// ```
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
fn count_ones(self) -> uint;
/// Returns the number of zeros in the binary representation of `self`.
@ -93,7 +98,8 @@ pub trait Int
///
/// assert_eq!(n.count_zeros(), 5);
/// ```
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
#[inline]
fn count_zeros(self) -> uint {
(!self).count_ones()
@ -111,7 +117,8 @@ pub trait Int
///
/// assert_eq!(n.leading_zeros(), 10);
/// ```
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
fn leading_zeros(self) -> uint;
/// Returns the number of trailing zeros in the binary representation
@ -126,7 +133,8 @@ pub trait Int
///
/// assert_eq!(n.trailing_zeros(), 3);
/// ```
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
fn trailing_zeros(self) -> uint;
/// Shifts the bits to the left by a specified amount amount, `n`, wrapping
@ -142,7 +150,8 @@ pub trait Int
///
/// assert_eq!(n.rotate_left(12), m);
/// ```
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
fn rotate_left(self, n: uint) -> Self;
/// Shifts the bits to the right by a specified amount amount, `n`, wrapping
@ -158,7 +167,8 @@ pub trait Int
///
/// assert_eq!(n.rotate_right(12), m);
/// ```
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
fn rotate_right(self, n: uint) -> Self;
/// Reverses the byte order of the integer.
@ -173,7 +183,7 @@ pub trait Int
///
/// assert_eq!(n.swap_bytes(), m);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn swap_bytes(self) -> Self;
/// Convert an integer from big endian to the target's endianness.
@ -193,7 +203,7 @@ pub trait Int
/// assert_eq!(Int::from_be(n), n.swap_bytes())
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn from_be(x: Self) -> Self {
if cfg!(target_endian = "big") { x } else { x.swap_bytes() }
@ -216,7 +226,7 @@ pub trait Int
/// assert_eq!(Int::from_le(n), n.swap_bytes())
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn from_le(x: Self) -> Self {
if cfg!(target_endian = "little") { x } else { x.swap_bytes() }
@ -239,7 +249,7 @@ pub trait Int
/// assert_eq!(n.to_be(), n.swap_bytes())
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn to_be(self) -> Self { // or not to be?
if cfg!(target_endian = "big") { self } else { self.swap_bytes() }
@ -262,7 +272,7 @@ pub trait Int
/// assert_eq!(n.to_le(), n.swap_bytes())
/// }
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn to_le(self) -> Self {
if cfg!(target_endian = "little") { self } else { self.swap_bytes() }
@ -279,7 +289,7 @@ pub trait Int
/// assert_eq!(5u16.checked_add(65530), Some(65535));
/// assert_eq!(6u16.checked_add(65530), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn checked_add(self, other: Self) -> Option<Self>;
/// Checked integer subtraction. Computes `self - other`, returning `None`
@ -293,7 +303,7 @@ pub trait Int
/// assert_eq!((-127i8).checked_sub(1), Some(-128));
/// assert_eq!((-128i8).checked_sub(1), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn checked_sub(self, other: Self) -> Option<Self>;
/// Checked integer multiplication. Computes `self * other`, returning
@ -307,7 +317,7 @@ pub trait Int
/// assert_eq!(5u8.checked_mul(51), Some(255));
/// assert_eq!(5u8.checked_mul(52), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn checked_mul(self, other: Self) -> Option<Self>;
/// Checked integer division. Computes `self / other`, returning `None` if
@ -322,12 +332,12 @@ pub trait Int
/// assert_eq!((-128i8).checked_div(-1), None);
/// assert_eq!((1i8).checked_div(0), None);
/// ```
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn checked_div(self, other: Self) -> Option<Self>;
/// Saturating integer addition. Computes `self + other`, saturating at
/// the numeric bounds instead of overflowing.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn saturating_add(self, other: Self) -> Self {
match self.checked_add(other) {
@ -339,7 +349,7 @@ pub trait Int
/// Saturating integer subtraction. Computes `self - other`, saturating at
/// the numeric bounds instead of overflowing.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn saturating_sub(self, other: Self) -> Self {
match self.checked_sub(other) {
@ -358,7 +368,8 @@ pub trait Int
///
/// assert_eq!(2i.pow(4), 16);
/// ```
#[unstable = "pending integer conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "pending integer conventions")]
#[inline]
fn pow(self, mut exp: uint) -> Self {
let mut base = self;
@ -390,7 +401,7 @@ macro_rules! uint_impl {
$add_with_overflow:path,
$sub_with_overflow:path,
$mul_with_overflow:path) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Int for $T {
#[inline]
fn zero() -> $T { 0 }
@ -521,7 +532,7 @@ macro_rules! int_impl {
$add_with_overflow:path,
$sub_with_overflow:path,
$mul_with_overflow:path) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Int for $T {
#[inline]
fn zero() -> $T { 0 }
@ -614,14 +625,14 @@ int_impl! { int = i64, u64, 64,
intrinsics::i64_mul_with_overflow }
/// A built-in two's complement integer.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait SignedInt
: Int
+ Neg<Output=Self>
{
/// Computes the absolute value of `self`. `Int::min_value()` will be
/// returned if the number is `Int::min_value()`.
#[unstable = "overflow in debug builds?"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "overflow in debug builds?")]
fn abs(self) -> Self;
/// Returns a number representing sign of `self`.
@ -629,23 +640,23 @@ pub trait SignedInt
/// - `0` if the number is zero
/// - `1` if the number is positive
/// - `-1` if the number is negative
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn signum(self) -> Self;
/// Returns `true` if `self` is positive and `false` if the number
/// is zero or negative.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn is_positive(self) -> bool;
/// Returns `true` if `self` is negative and `false` if the number
/// is zero or positive.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn is_negative(self) -> bool;
}
macro_rules! signed_int_impl {
($T:ty) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl SignedInt for $T {
#[inline]
fn abs(self) -> $T {
@ -677,10 +688,10 @@ signed_int_impl! { i64 }
signed_int_impl! { int }
/// A built-in unsigned integer.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait UnsignedInt: Int {
/// Returns `true` iff `self == 2^k` for some `k`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn is_power_of_two(self) -> bool {
(self - Int::one()) & self == Int::zero() && !(self == Int::zero())
@ -688,7 +699,7 @@ pub trait UnsignedInt: Int {
/// Returns the smallest power of two greater than or equal to `self`.
/// Unspecified behavior on overflow.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn next_power_of_two(self) -> Self {
let bits = size_of::<Self>() * 8;
@ -699,7 +710,7 @@ pub trait UnsignedInt: Int {
/// Returns the smallest power of two greater than or equal to `n`. If the
/// next power of two is greater than the type's maximum value, `None` is
/// returned, otherwise the power of two is wrapped in `Some`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn checked_next_power_of_two(self) -> Option<Self> {
let npot = self.next_power_of_two();
if npot >= self {
@ -710,23 +721,23 @@ pub trait UnsignedInt: Int {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl UnsignedInt for uint {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl UnsignedInt for u8 {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl UnsignedInt for u16 {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl UnsignedInt for u32 {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl UnsignedInt for u64 {}
/// A generic trait for converting a value to a number.
#[unstable = "trait is likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is likely to be removed")]
pub trait ToPrimitive {
/// Converts the value of `self` to an `int`.
#[inline]
@ -991,7 +1002,7 @@ impl_to_primitive_float! { f32 }
impl_to_primitive_float! { f64 }
/// A generic trait for converting a number to a value.
#[unstable = "trait is likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is likely to be removed")]
pub trait FromPrimitive : ::marker::Sized {
/// Convert an `int` to return an optional value of this type. If the
/// value cannot be represented by this value, the `None` is returned.
@ -1073,73 +1084,73 @@ pub trait FromPrimitive : ::marker::Sized {
}
/// A utility function that just calls `FromPrimitive::from_int`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_int<A: FromPrimitive>(n: int) -> Option<A> {
FromPrimitive::from_int(n)
}
/// A utility function that just calls `FromPrimitive::from_i8`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_i8<A: FromPrimitive>(n: i8) -> Option<A> {
FromPrimitive::from_i8(n)
}
/// A utility function that just calls `FromPrimitive::from_i16`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_i16<A: FromPrimitive>(n: i16) -> Option<A> {
FromPrimitive::from_i16(n)
}
/// A utility function that just calls `FromPrimitive::from_i32`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_i32<A: FromPrimitive>(n: i32) -> Option<A> {
FromPrimitive::from_i32(n)
}
/// A utility function that just calls `FromPrimitive::from_i64`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_i64<A: FromPrimitive>(n: i64) -> Option<A> {
FromPrimitive::from_i64(n)
}
/// A utility function that just calls `FromPrimitive::from_uint`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_uint<A: FromPrimitive>(n: uint) -> Option<A> {
FromPrimitive::from_uint(n)
}
/// A utility function that just calls `FromPrimitive::from_u8`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_u8<A: FromPrimitive>(n: u8) -> Option<A> {
FromPrimitive::from_u8(n)
}
/// A utility function that just calls `FromPrimitive::from_u16`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_u16<A: FromPrimitive>(n: u16) -> Option<A> {
FromPrimitive::from_u16(n)
}
/// A utility function that just calls `FromPrimitive::from_u32`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_u32<A: FromPrimitive>(n: u32) -> Option<A> {
FromPrimitive::from_u32(n)
}
/// A utility function that just calls `FromPrimitive::from_u64`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_u64<A: FromPrimitive>(n: u64) -> Option<A> {
FromPrimitive::from_u64(n)
}
/// A utility function that just calls `FromPrimitive::from_f32`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_f32<A: FromPrimitive>(n: f32) -> Option<A> {
FromPrimitive::from_f32(n)
}
/// A utility function that just calls `FromPrimitive::from_f64`.
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn from_f64<A: FromPrimitive>(n: f64) -> Option<A> {
FromPrimitive::from_f64(n)
}
@ -1190,13 +1201,13 @@ impl_from_primitive! { f64, to_f64 }
/// ```
///
#[inline]
#[unstable = "likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")]
pub fn cast<T: NumCast,U: NumCast>(n: T) -> Option<U> {
NumCast::from(n)
}
/// An interface for casting between machine scalars.
#[unstable = "trait is likely to be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is likely to be removed")]
pub trait NumCast: ToPrimitive {
/// Creates a number from another value that can be converted into a primitive via the
/// `ToPrimitive` trait.
@ -1231,7 +1242,7 @@ impl_num_cast! { f64, to_f64 }
/// Used for representing the classification of floating point numbers
#[derive(Copy, PartialEq, Show)]
#[unstable = "may be renamed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed")]
pub enum FpCategory {
/// "Not a Number", often obtained by dividing by zero
Nan,
@ -1251,7 +1262,8 @@ pub enum FpCategory {
//
// FIXME(#8888): Several of these functions have a parameter named
// `unused_self`. Removing it requires #8888 to be fixed.
#[unstable = "distribution of methods between core/std is unclear"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "distribution of methods between core/std is unclear")]
pub trait Float
: Copy + Clone
+ NumCast
@ -1280,34 +1292,46 @@ pub trait Float
// FIXME (#5527): These should be associated constants
/// Returns the number of binary digits of mantissa that this type supports.
#[deprecated = "use `std::f32::MANTISSA_DIGITS` or `std::f64::MANTISSA_DIGITS` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::MANTISSA_DIGITS` or \
`std::f64::MANTISSA_DIGITS` as appropriate")]
fn mantissa_digits(unused_self: Option<Self>) -> uint;
/// Returns the number of base-10 digits of precision that this type supports.
#[deprecated = "use `std::f32::DIGITS` or `std::f64::DIGITS` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::DIGITS` or `std::f64::DIGITS` as appropriate")]
fn digits(unused_self: Option<Self>) -> uint;
/// Returns the difference between 1.0 and the smallest representable number larger than 1.0.
#[deprecated = "use `std::f32::EPSILON` or `std::f64::EPSILON` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::EPSILON` or `std::f64::EPSILON` as appropriate")]
fn epsilon() -> Self;
/// Returns the minimum binary exponent that this type can represent.
#[deprecated = "use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` as appropriate")]
fn min_exp(unused_self: Option<Self>) -> int;
/// Returns the maximum binary exponent that this type can represent.
#[deprecated = "use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` as appropriate")]
fn max_exp(unused_self: Option<Self>) -> int;
/// Returns the minimum base-10 exponent that this type can represent.
#[deprecated = "use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` as appropriate")]
fn min_10_exp(unused_self: Option<Self>) -> int;
/// Returns the maximum base-10 exponent that this type can represent.
#[deprecated = "use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` as appropriate")]
fn max_10_exp(unused_self: Option<Self>) -> int;
/// Returns the smallest finite value that this type can represent.
#[deprecated = "use `std::f32::MIN_VALUE` or `std::f64::MIN_VALUE` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::MIN_VALUE` or `std::f64::MIN_VALUE` as appropriate")]
fn min_value() -> Self;
/// Returns the smallest normalized positive number that this type can represent.
#[deprecated = "use `std::f32::MIN_POS_VALUE` or `std::f64::MIN_POS_VALUE` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::MIN_POS_VALUE` or \
`std::f64::MIN_POS_VALUE` as appropriate")]
fn min_pos_value(unused_self: Option<Self>) -> Self;
/// Returns the largest finite value that this type can represent.
#[deprecated = "use `std::f32::MAX_VALUE` or `std::f64::MAX_VALUE` as appropriate"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `std::f32::MAX_VALUE` or `std::f64::MAX_VALUE` as appropriate")]
fn max_value() -> Self;
/// Returns true if this value is NaN and false otherwise.
@ -1394,20 +1418,21 @@ pub trait Float
}
/// A generic trait for converting a string with a radix (base) to a value
#[unstable = "might need to return Result"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "might need to return Result")]
pub trait FromStrRadix {
fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
}
/// A utility function that just calls FromStrRadix::from_str_radix.
#[unstable = "might need to return Result"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "might need to return Result")]
pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
FromStrRadix::from_str_radix(str, radix)
}
macro_rules! from_str_radix_float_impl {
($T:ty) => {
#[unstable = "might need to return Result"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "might need to return Result")]
impl FromStr for $T {
/// Convert a string in base 10 to a float.
/// Accepts an optional decimal exponent.
@ -1440,7 +1465,8 @@ macro_rules! from_str_radix_float_impl {
}
}
#[unstable = "might need to return Result"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "might need to return Result")]
impl FromStrRadix for $T {
/// Convert a string in a given base to a float.
///
@ -1604,7 +1630,8 @@ from_str_radix_float_impl! { f64 }
macro_rules! from_str_radix_int_impl {
($T:ty) => {
#[unstable = "might need to return Result"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "might need to return Result")]
impl FromStr for $T {
#[inline]
fn from_str(src: &str) -> Option<$T> {
@ -1612,7 +1639,8 @@ macro_rules! from_str_radix_int_impl {
}
}
#[unstable = "might need to return Result"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "might need to return Result")]
impl FromStrRadix for $T {
fn from_str_radix(src: &str, radix: uint) -> Option<$T> {
assert!(radix >= 2 && radix <= 36,

2
src/libcore/num/u16.rs
View File

@ -10,7 +10,7 @@
//! Operations and constants for unsigned 16-bits integers (`u16` type)
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "u16")]
uint_module! { u16, i16, 16 }

2
src/libcore/num/u32.rs
View File

@ -10,7 +10,7 @@
//! Operations and constants for unsigned 32-bits integers (`u32` type)
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "u32")]
uint_module! { u32, i32, 32 }

2
src/libcore/num/u64.rs
View File

@ -10,7 +10,7 @@
//! Operations and constants for unsigned 64-bits integer (`u64` type)
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "u64")]
uint_module! { u64, i64, 64 }

2
src/libcore/num/u8.rs
View File

@ -10,7 +10,7 @@
//! Operations and constants for unsigned 8-bits integers (`u8` type)
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "u8")]
uint_module! { u8, i8, 8 }

2
src/libcore/num/uint.rs
View File

@ -14,6 +14,6 @@
//! alpha cycle along with the development of clearer conventions
//! around integer types.
#![deprecated = "replaced by usize"]
#![deprecated(feature = "oldstuff", since = "1.0.0", reason = "replaced by usize")]
uint_module! { uint, int, ::int::BITS }

8
src/libcore/num/uint_macros.rs
View File

@ -12,14 +12,14 @@
macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => (
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub const BITS : uint = $bits;
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub const BYTES : uint = ($bits / 8);
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MIN: $T = 0 as $T;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub const MAX: $T = 0 as $T - 1 as $T;
) }

2
src/libcore/num/usize.rs
View File

@ -14,7 +14,7 @@
//! new type will gradually take place over the alpha cycle along with
//! the development of clearer conventions around integer types.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "usize")]
uint_module! { usize, isize, ::isize::BITS }

169
src/libcore/ops.rs
View File

@ -67,7 +67,7 @@
//! See the documentation for each trait for a minimum implementation that prints
//! something to the screen.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use clone::Clone;
use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator};
@ -97,10 +97,10 @@ use fmt;
/// }
/// ```
#[lang="drop"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Drop {
/// The `drop` method, called when the value goes out of scope.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn drop(&mut self);
}
@ -108,7 +108,8 @@ pub trait Drop {
// based on "op T" where T is expected to be `Copy`able
macro_rules! forward_ref_unop {
(impl $imp:ident, $method:ident for $t:ty) => {
#[unstable = "recently added, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recently added, waiting for dust to settle")]
impl<'a> $imp for &'a $t {
type Output = <$t as $imp>::Output;
@ -124,7 +125,8 @@ macro_rules! forward_ref_unop {
// based on "T op U" where T and U are expected to be `Copy`able
macro_rules! forward_ref_binop {
(impl $imp:ident, $method:ident for $t:ty, $u:ty) => {
#[unstable = "recently added, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recently added, waiting for dust to settle")]
impl<'a> $imp<$u> for &'a $t {
type Output = <$t as $imp<$u>>::Output;
@ -134,7 +136,8 @@ macro_rules! forward_ref_binop {
}
}
#[unstable = "recently added, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recently added, waiting for dust to settle")]
impl<'a> $imp<&'a $u> for $t {
type Output = <$t as $imp<$u>>::Output;
@ -144,7 +147,8 @@ macro_rules! forward_ref_binop {
}
}
#[unstable = "recently added, waiting for dust to settle"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recently added, waiting for dust to settle")]
impl<'a, 'b> $imp<&'a $u> for &'b $t {
type Output = <$t as $imp<$u>>::Output;
@ -185,19 +189,19 @@ macro_rules! forward_ref_binop {
/// }
/// ```
#[lang="add"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Add<RHS=Self> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the `+` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn add(self, rhs: RHS) -> Self::Output;
}
macro_rules! add_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Add for $t {
type Output = $t;
@ -240,19 +244,19 @@ add_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 }
/// }
/// ```
#[lang="sub"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Sub<RHS=Self> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the `-` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn sub(self, rhs: RHS) -> Self::Output;
}
macro_rules! sub_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Sub for $t {
type Output = $t;
@ -295,19 +299,19 @@ sub_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 }
/// }
/// ```
#[lang="mul"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Mul<RHS=Self> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the `*` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn mul(self, rhs: RHS) -> Self::Output;
}
macro_rules! mul_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Mul for $t {
type Output = $t;
@ -350,19 +354,19 @@ mul_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 }
/// }
/// ```
#[lang="div"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Div<RHS=Self> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the `/` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn div(self, rhs: RHS) -> Self::Output;
}
macro_rules! div_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Div for $t {
type Output = $t;
@ -405,19 +409,19 @@ div_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 }
/// }
/// ```
#[lang="rem"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Rem<RHS=Self> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output = Self;
/// The method for the `%` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn rem(self, rhs: RHS) -> Self::Output;
}
macro_rules! rem_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Rem for $t {
type Output = $t;
@ -431,7 +435,7 @@ macro_rules! rem_impl {
macro_rules! rem_float_impl {
($t:ty, $fmod:ident) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Rem for $t {
type Output = $t;
@ -480,25 +484,25 @@ rem_float_impl! { f64, fmod }
/// }
/// ```
#[lang="neg"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Neg {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the unary `-` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn neg(self) -> Self::Output;
}
macro_rules! neg_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Neg for $t {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output = $t;
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn neg(self) -> $t { -self }
}
@ -508,7 +512,7 @@ macro_rules! neg_impl {
macro_rules! neg_uint_impl {
($t:ty, $t_signed:ty) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Neg for $t {
type Output = $t;
@ -559,19 +563,19 @@ neg_uint_impl! { u64, i64 }
/// }
/// ```
#[lang="not"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Not {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the unary `!` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn not(self) -> Self::Output;
}
macro_rules! not_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Not for $t {
type Output = $t;
@ -614,19 +618,19 @@ not_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 }
/// }
/// ```
#[lang="bitand"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait BitAnd<RHS=Self> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the `&` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn bitand(self, rhs: RHS) -> Self::Output;
}
macro_rules! bitand_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl BitAnd for $t {
type Output = $t;
@ -669,19 +673,19 @@ bitand_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 }
/// }
/// ```
#[lang="bitor"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait BitOr<RHS=Self> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the `|` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn bitor(self, rhs: RHS) -> Self::Output;
}
macro_rules! bitor_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl BitOr for $t {
type Output = $t;
@ -724,19 +728,19 @@ bitor_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 }
/// }
/// ```
#[lang="bitxor"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait BitXor<RHS=Self> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the `^` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn bitxor(self, rhs: RHS) -> Self::Output;
}
macro_rules! bitxor_impl {
($($t:ty)*) => ($(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl BitXor for $t {
type Output = $t;
@ -779,19 +783,19 @@ bitxor_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 }
/// }
/// ```
#[lang="shl"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Shl<RHS> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the `<<` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn shl(self, rhs: RHS) -> Self::Output;
}
macro_rules! shl_impl {
($t:ty, $f:ty) => (
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Shl<$f> for $t {
type Output = $t;
@ -852,13 +856,13 @@ shl_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize }
/// }
/// ```
#[lang="shr"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Shr<RHS> {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Output;
/// The method for the `>>` operator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn shr(self, rhs: RHS) -> Self::Output;
}
@ -970,10 +974,10 @@ pub trait IndexMut<Index: ?Sized> {
/// An unbounded range.
#[derive(Copy, Clone, PartialEq, Eq)]
#[lang="full_range"]
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
pub struct FullRange;
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
impl fmt::Show for FullRange {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt::Show::fmt("..", fmt)
@ -983,7 +987,7 @@ impl fmt::Show for FullRange {
/// A (half-open) range which is bounded at both ends.
#[derive(Copy, Clone, PartialEq, Eq)]
#[lang="range"]
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
pub struct Range<Idx> {
/// The lower bound of the range (inclusive).
pub start: Idx,
@ -991,7 +995,7 @@ pub struct Range<Idx> {
pub end: Idx,
}
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
impl<Idx: Clone + Step> Iterator for Range<Idx> {
type Item = Idx;
@ -1016,7 +1020,7 @@ impl<Idx: Clone + Step> Iterator for Range<Idx> {
}
}
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
#[inline]
fn next_back(&mut self) -> Option<Idx> {
@ -1029,10 +1033,10 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
}
}
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{:?}..{:?}", self.start, self.end)
@ -1042,13 +1046,13 @@ impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
/// A range which is only bounded below.
#[derive(Copy, Clone, PartialEq, Eq)]
#[lang="range_from"]
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
pub struct RangeFrom<Idx> {
/// The lower bound of the range (inclusive).
pub start: Idx,
}
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
type Item = Idx;
@ -1061,7 +1065,7 @@ impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
}
}
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{:?}..", self.start)
@ -1071,13 +1075,13 @@ impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
/// A range which is only bounded above.
#[derive(Copy, Clone, PartialEq, Eq)]
#[lang="range_to"]
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
pub struct RangeTo<Idx> {
/// The upper bound of the range (exclusive).
pub end: Idx,
}
#[unstable = "API still in development"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")]
impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "..{:?}", self.end)
@ -1116,24 +1120,24 @@ impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> {
/// }
/// ```
#[lang="deref"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait Deref {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
type Target: ?Sized;
/// The method called to dereference a value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn deref<'a>(&'a self) -> &'a Self::Target;
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: ?Sized> Deref for &'a T {
type Target = T;
fn deref(&self) -> &T { *self }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: ?Sized> Deref for &'a mut T {
type Target = T;
@ -1178,21 +1182,22 @@ impl<'a, T: ?Sized> Deref for &'a mut T {
/// }
/// ```
#[lang="deref_mut"]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait DerefMut: Deref {
/// The method called to mutably dereference a value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn deref_mut<'a>(&'a mut self) -> &'a mut Self::Target;
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T: ?Sized> DerefMut for &'a mut T {
fn deref_mut(&mut self) -> &mut T { *self }
}
/// A version of the call operator that takes an immutable receiver.
#[lang="fn"]
#[unstable = "uncertain about variadic generics, input versus associated types"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "uncertain about variadic generics, input versus associated types")]
pub trait Fn<Args,Result> {
/// This is called when the call operator is used.
extern "rust-call" fn call(&self, args: Args) -> Result;
@ -1200,7 +1205,8 @@ pub trait Fn<Args,Result> {
/// A version of the call operator that takes a mutable receiver.
#[lang="fn_mut"]
#[unstable = "uncertain about variadic generics, input versus associated types"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "uncertain about variadic generics, input versus associated types")]
pub trait FnMut<Args,Result> {
/// This is called when the call operator is used.
extern "rust-call" fn call_mut(&mut self, args: Args) -> Result;
@ -1208,7 +1214,8 @@ pub trait FnMut<Args,Result> {
/// A version of the call operator that takes a by-value receiver.
#[lang="fn_once"]
#[unstable = "uncertain about variadic generics, input versus associated types"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "uncertain about variadic generics, input versus associated types")]
pub trait FnOnce<Args,Result> {
/// This is called when the call operator is used.
extern "rust-call" fn call_once(self, args: Args) -> Result;

96
src/libcore/option.rs
View File

@ -141,7 +141,7 @@
//! }
//! ```
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use self::Option::*;
@ -164,13 +164,13 @@ use slice;
/// The `Option` type.
#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Show, Hash)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub enum Option<T> {
/// No value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
None,
/// Some value `T`
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
Some(T)
}
@ -195,7 +195,7 @@ impl<T> Option<T> {
/// assert_eq!(x.is_some(), false);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_some(&self) -> bool {
match *self {
Some(_) => true,
@ -215,7 +215,7 @@ impl<T> Option<T> {
/// assert_eq!(x.is_none(), true);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_none(&self) -> bool {
!self.is_some()
}
@ -241,7 +241,7 @@ impl<T> Option<T> {
/// println!("still can print num_as_str: {:?}", num_as_str);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn as_ref<'r>(&'r self) -> Option<&'r T> {
match *self {
Some(ref x) => Some(x),
@ -262,7 +262,7 @@ impl<T> Option<T> {
/// assert_eq!(x, Some(42u));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn as_mut<'r>(&'r mut self) -> Option<&'r mut T> {
match *self {
Some(ref mut x) => Some(x),
@ -285,7 +285,8 @@ impl<T> Option<T> {
/// assert_eq!(x, Some("Dirt"));
/// ```
#[inline]
#[unstable = "waiting for mut conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "waiting for mut conventions")]
pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] {
match *self {
Some(ref mut x) => {
@ -322,7 +323,7 @@ impl<T> Option<T> {
/// x.expect("the world is ending"); // panics with `world is ending`
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn expect(self, msg: &str) -> T {
match self {
Some(val) => val,
@ -354,7 +355,7 @@ impl<T> Option<T> {
/// assert_eq!(x.unwrap(), "air"); // fails
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn unwrap(self) -> T {
match self {
Some(val) => val,
@ -371,7 +372,7 @@ impl<T> Option<T> {
/// assert_eq!(None.unwrap_or("bike"), "bike");
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn unwrap_or(self, def: T) -> T {
match self {
Some(x) => x,
@ -389,7 +390,7 @@ impl<T> Option<T> {
/// assert_eq!(None.unwrap_or_else(|| 2 * k), 20u);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T {
match self {
Some(x) => x,
@ -413,7 +414,7 @@ impl<T> Option<T> {
/// let num_as_int: Option<uint> = num_as_str.map(|n| n.len());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> {
match self {
Some(x) => Some(f(x)),
@ -433,7 +434,7 @@ impl<T> Option<T> {
/// assert_eq!(x.map_or(42u, |v| v.len()), 42u);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn map_or<U, F: FnOnce(T) -> U>(self, def: U, f: F) -> U {
match self {
Some(t) => f(t),
@ -455,7 +456,7 @@ impl<T> Option<T> {
/// assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42u);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn map_or_else<U, D: FnOnce() -> U, F: FnOnce(T) -> U>(self, def: D, f: F) -> U {
match self {
Some(t) => f(t),
@ -476,7 +477,7 @@ impl<T> Option<T> {
/// assert_eq!(x.ok_or(0i), Err(0i));
/// ```
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn ok_or<E>(self, err: E) -> Result<T, E> {
match self {
Some(v) => Ok(v),
@ -497,7 +498,7 @@ impl<T> Option<T> {
/// assert_eq!(x.ok_or_else(|| 0i), Err(0i));
/// ```
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> {
match self {
Some(v) => Ok(v),
@ -521,7 +522,7 @@ impl<T> Option<T> {
/// assert_eq!(x.iter().next(), None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
Iter { inner: Item { opt: self.as_ref() } }
}
@ -542,7 +543,8 @@ impl<T> Option<T> {
/// assert_eq!(x.iter_mut().next(), None);
/// ```
#[inline]
#[unstable = "waiting for iterator conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "waiting for iterator conventions")]
pub fn iter_mut(&mut self) -> IterMut<T> {
IterMut { inner: Item { opt: self.as_mut() } }
}
@ -561,7 +563,7 @@ impl<T> Option<T> {
/// assert!(v.is_empty());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<T> {
IntoIter { inner: Item { opt: self } }
}
@ -592,7 +594,7 @@ impl<T> Option<T> {
/// assert_eq!(x.and(y), None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn and<U>(self, optb: Option<U>) -> Option<U> {
match self {
Some(_) => optb,
@ -615,7 +617,7 @@ impl<T> Option<T> {
/// assert_eq!(None.and_then(sq).and_then(sq), None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn and_then<U, F: FnOnce(T) -> Option<U>>(self, f: F) -> Option<U> {
match self {
Some(x) => f(x),
@ -645,7 +647,7 @@ impl<T> Option<T> {
/// assert_eq!(x.or(y), None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn or(self, optb: Option<T>) -> Option<T> {
match self {
Some(_) => self,
@ -667,7 +669,7 @@ impl<T> Option<T> {
/// assert_eq!(None.or_else(nobody), None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn or_else<F: FnOnce() -> Option<T>>(self, f: F) -> Option<T> {
match self {
Some(_) => self,
@ -693,7 +695,7 @@ impl<T> Option<T> {
/// assert_eq!(x, None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn take(&mut self) -> Option<T> {
mem::replace(self, None)
}
@ -702,7 +704,8 @@ impl<T> Option<T> {
impl<'a, T: Clone, D: Deref<Target=T>> Option<D> {
/// Maps an Option<D> to an Option<T> by dereffing and cloning the contents of the Option.
/// Useful for converting an Option<&T> to an Option<T>.
#[unstable = "recently added as part of collections reform"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recently added as part of collections reform")]
pub fn cloned(self) -> Option<T> {
self.map(|t| t.deref().clone())
}
@ -732,7 +735,7 @@ impl<T: Default> Option<T> {
/// assert_eq!(0i, bad_year);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn unwrap_or_default(self) -> T {
match self {
Some(x) => x,
@ -745,7 +748,8 @@ impl<T: Default> Option<T> {
// Trait implementations
/////////////////////////////////////////////////////////////////////////////
#[unstable = "waiting on the stability of the trait itself"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "waiting on the stability of the trait itself")]
impl<T> AsSlice<T> for Option<T> {
/// Convert from `Option<T>` to `&[T]` (without copying)
#[inline]
@ -760,10 +764,10 @@ impl<T> AsSlice<T> for Option<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Default for Option<T> {
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> Option<T> { None }
}
@ -803,10 +807,10 @@ impl<A> DoubleEndedIterator for Item<A> {
impl<A> ExactSizeIterator for Item<A> {}
/// An iterator over a reference of the contained item in an Option.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Iter<'a, A: 'a> { inner: Item<&'a A> }
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> Iterator for Iter<'a, A> {
type Item = &'a A;
@ -816,16 +820,16 @@ impl<'a, A> Iterator for Iter<'a, A> {
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
#[inline]
fn next_back(&mut self) -> Option<&'a A> { self.inner.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> ExactSizeIterator for Iter<'a, A> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> Clone for Iter<'a, A> {
fn clone(&self) -> Iter<'a, A> {
Iter { inner: self.inner.clone() }
@ -833,10 +837,10 @@ impl<'a, A> Clone for Iter<'a, A> {
}
/// An iterator over a mutable reference of the contained item in an Option.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IterMut<'a, A: 'a> { inner: Item<&'a mut A> }
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> Iterator for IterMut<'a, A> {
type Item = &'a mut A;
@ -846,20 +850,20 @@ impl<'a, A> Iterator for IterMut<'a, A> {
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
#[inline]
fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, A> ExactSizeIterator for IterMut<'a, A> {}
/// An iterator over the item contained inside an Option.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IntoIter<A> { inner: Item<A> }
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> Iterator for IntoIter<A> {
type Item = A;
@ -869,20 +873,20 @@ impl<A> Iterator for IntoIter<A> {
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> DoubleEndedIterator for IntoIter<A> {
#[inline]
fn next_back(&mut self) -> Option<A> { self.inner.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A> ExactSizeIterator for IntoIter<A> {}
/////////////////////////////////////////////////////////////////////////////
// FromIterator
/////////////////////////////////////////////////////////////////////////////
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
/// Takes each element in the `Iterator`: if it is `None`, no further
/// elements are taken, and the `None` is returned. Should no `None` occur, a
@ -902,7 +906,7 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
/// assert!(res == Some(vec!(2u, 3u)));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn from_iter<I: Iterator<Item=Option<A>>>(iter: I) -> Option<V> {
// FIXME(#11084): This could be replaced with Iterator::scan when this
// performance bug is closed.

110
src/libcore/ptr.rs
View File

@ -86,7 +86,7 @@
//! but C APIs hand out a lot of pointers generally, so are a common source
//! of unsafe pointers in Rust.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use mem;
use clone::Clone;
@ -99,13 +99,14 @@ use cmp::Ordering::{self, Less, Equal, Greater};
// FIXME #19649: intrinsic docs don't render, so these have no docs :(
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub use intrinsics::copy_nonoverlapping_memory;
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub use intrinsics::copy_memory;
#[unstable = "uncertain about naming and semantics"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "uncertain about naming and semantics")]
pub use intrinsics::set_memory;
@ -120,7 +121,7 @@ pub use intrinsics::set_memory;
/// assert!(p.is_null());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn null<T>() -> *const T { 0 as *const T }
/// Creates a null mutable raw pointer.
@ -134,7 +135,7 @@ pub fn null<T>() -> *const T { 0 as *const T }
/// assert!(p.is_null());
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn null_mut<T>() -> *mut T { 0 as *mut T }
/// Zeroes out `count * size_of::<T>` bytes of memory at `dst`. `count` may be
@ -145,7 +146,8 @@ pub fn null_mut<T>() -> *mut T { 0 as *mut T }
/// Beyond accepting a raw pointer, this is unsafe because it will not drop the
/// contents of `dst`, and may be used to create invalid instances of `T`.
#[inline]
#[unstable = "may play a larger role in std::ptr future extensions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "may play a larger role in std::ptr future extensions")]
pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
set_memory(dst, 0, count);
}
@ -158,7 +160,7 @@ pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
///
/// This is only unsafe because it accepts a raw pointer.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
// Give ourselves some scratch space to work with
let mut tmp: T = mem::uninitialized();
@ -182,7 +184,7 @@ pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
/// This is only unsafe because it accepts a raw pointer.
/// Otherwise, this operation is identical to `mem::replace`.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn replace<T>(dest: *mut T, mut src: T) -> T {
mem::swap(mem::transmute(dest), &mut src); // cannot overlap
src
@ -200,7 +202,7 @@ pub unsafe fn replace<T>(dest: *mut T, mut src: T) -> T {
/// `zero_memory`, or `copy_memory`). Note that `*src = foo` counts as a use
/// because it will attempt to drop the value previously at `*src`.
#[inline(always)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn read<T>(src: *const T) -> T {
let mut tmp: T = mem::uninitialized();
copy_nonoverlapping_memory(&mut tmp, src, 1);
@ -213,7 +215,8 @@ pub unsafe fn read<T>(src: *const T) -> T {
///
/// This is unsafe for the same reasons that `read` is unsafe.
#[inline(always)]
#[unstable = "may play a larger role in std::ptr future extensions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "may play a larger role in std::ptr future extensions")]
pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
// Copy the data out from `dest`:
let tmp = read(&*dest);
@ -236,18 +239,18 @@ pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
/// This is appropriate for initializing uninitialized memory, or overwriting
/// memory that has previously been `read` from.
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn write<T>(dst: *mut T, src: T) {
intrinsics::move_val_init(&mut *dst, src)
}
/// Methods on raw pointers
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait PtrExt: Sized {
type Target;
/// Returns true if the pointer is null.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn is_null(self) -> bool;
/// Returns `None` if the pointer is null, or else returns a reference to
@ -259,8 +262,9 @@ pub trait PtrExt: Sized {
/// null-safety, it is important to note that this is still an unsafe
/// operation because the returned value could be pointing to invalid
/// memory.
#[unstable = "Option is not clearly the right return type, and we may want \
to tie the return lifetime to a borrow of the raw pointer"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Option is not clearly the right return type, and we may want \
to tie the return lifetime to a borrow of the raw pointer")]
unsafe fn as_ref<'a>(&self) -> Option<&'a Self::Target>;
/// Calculates the offset from a pointer. `count` is in units of T; e.g. a
@ -271,12 +275,12 @@ pub trait PtrExt: Sized {
/// The offset must be in-bounds of the object, or one-byte-past-the-end.
/// Otherwise `offset` invokes Undefined Behaviour, regardless of whether
/// the pointer is used.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn offset(self, count: int) -> Self;
}
/// Methods on mutable raw pointers
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub trait MutPtrExt {
type Target;
@ -287,28 +291,30 @@ pub trait MutPtrExt {
///
/// As with `as_ref`, this is unsafe because it cannot verify the validity
/// of the returned pointer.
#[unstable = "Option is not clearly the right return type, and we may want \
to tie the return lifetime to a borrow of the raw pointer"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Option is not clearly the right return type, and we may want \
to tie the return lifetime to a borrow of the raw pointer")]
unsafe fn as_mut<'a>(&self) -> Option<&'a mut Self::Target>;
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> PtrExt for *const T {
type Target = T;
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn is_null(self) -> bool { self as uint == 0 }
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn offset(self, count: int) -> *const T {
intrinsics::offset(self, count)
}
#[inline]
#[unstable = "return value does not necessarily convey all possible \
information"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "return value does not necessarily convey all possible \
information")]
unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
if self.is_null() {
None
@ -318,23 +324,24 @@ impl<T> PtrExt for *const T {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> PtrExt for *mut T {
type Target = T;
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn is_null(self) -> bool { self as uint == 0 }
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
unsafe fn offset(self, count: int) -> *mut T {
intrinsics::offset(self, count) as *mut T
}
#[inline]
#[unstable = "return value does not necessarily convey all possible \
information"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "return value does not necessarily convey all possible \
information")]
unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
if self.is_null() {
None
@ -344,13 +351,14 @@ impl<T> PtrExt for *mut T {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> MutPtrExt for *mut T {
type Target = T;
#[inline]
#[unstable = "return value does not necessarily convey all possible \
information"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "return value does not necessarily convey all possible \
information")]
unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> {
if self.is_null() {
None
@ -361,7 +369,7 @@ impl<T> MutPtrExt for *mut T {
}
// Equality for pointers
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> PartialEq for *const T {
#[inline]
fn eq(&self, other: &*const T) -> bool {
@ -371,10 +379,10 @@ impl<T> PartialEq for *const T {
fn ne(&self, other: &*const T) -> bool { !self.eq(other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Eq for *const T {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> PartialEq for *mut T {
#[inline]
fn eq(&self, other: &*mut T) -> bool {
@ -384,10 +392,10 @@ impl<T> PartialEq for *mut T {
fn ne(&self, other: &*mut T) -> bool { !self.eq(other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Eq for *mut T {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Clone for *const T {
#[inline]
fn clone(&self) -> *const T {
@ -395,7 +403,7 @@ impl<T> Clone for *const T {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Clone for *mut T {
#[inline]
fn clone(&self) -> *mut T {
@ -408,7 +416,7 @@ mod externfnpointers {
use mem;
use cmp::PartialEq;
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<_R> PartialEq for extern "C" fn() -> _R {
#[inline]
fn eq(&self, other: &extern "C" fn() -> _R) -> bool {
@ -419,7 +427,7 @@ mod externfnpointers {
}
macro_rules! fnptreq {
($($p:ident),*) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<_R,$($p),*> PartialEq for extern "C" fn($($p),*) -> _R {
#[inline]
fn eq(&self, other: &extern "C" fn($($p),*) -> _R) -> bool {
@ -439,7 +447,7 @@ mod externfnpointers {
}
// Comparison for pointers
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Ord for *const T {
#[inline]
fn cmp(&self, other: &*const T) -> Ordering {
@ -453,7 +461,7 @@ impl<T> Ord for *const T {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> PartialOrd for *const T {
#[inline]
fn partial_cmp(&self, other: &*const T) -> Option<Ordering> {
@ -473,7 +481,7 @@ impl<T> PartialOrd for *const T {
fn ge(&self, other: &*const T) -> bool { *self >= *other }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Ord for *mut T {
#[inline]
fn cmp(&self, other: &*mut T) -> Ordering {
@ -487,7 +495,7 @@ impl<T> Ord for *mut T {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> PartialOrd for *mut T {
#[inline]
fn partial_cmp(&self, other: &*mut T) -> Option<Ordering> {
@ -513,32 +521,34 @@ impl<T> PartialOrd for *mut T {
/// raw `*mut T` (which conveys no particular ownership semantics).
/// Useful for building abstractions like `Vec<T>` or `Box<T>`, which
/// internally use raw pointers to manage the memory that they own.
#[unstable = "recently added to this module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recently added to this module")]
pub struct Unique<T>(pub *mut T);
/// `Unique` pointers are `Send` if `T` is `Send` because the data they
/// reference is unaliased. Note that this aliasing invariant is
/// unenforced by the type system; the abstraction using the
/// `Unique` must enforce it.
#[unstable = "recently added to this module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recently added to this module")]
unsafe impl<T:Send> Send for Unique<T> { }
/// `Unique` pointers are `Sync` if `T` is `Sync` because the data they
/// reference is unaliased. Note that this aliasing invariant is
/// unenforced by the type system; the abstraction using the
/// `Unique` must enforce it.
#[unstable = "recently added to this module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recently added to this module")]
unsafe impl<T:Sync> Sync for Unique<T> { }
impl<T> Unique<T> {
/// Returns a null Unique.
#[unstable = "recently added to this module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recently added to this module")]
pub fn null() -> Unique<T> {
Unique(null_mut())
}
/// Return an (unsafe) pointer into the memory owned by `self`.
#[unstable = "recently added to this module"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "recently added to this module")]
pub unsafe fn offset(self, offset: int) -> *mut T {
self.0.offset(offset)
}

2
src/libcore/raw.rs
View File

@ -9,7 +9,7 @@
// except according to those terms.
#![allow(missing_docs)]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
//! Contains struct definitions for the layout of compiler built-in types.
//!

85
src/libcore/result.rs
View File

@ -224,7 +224,7 @@
//!
//! `try!` is imported by the prelude, and is available everywhere.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use self::Result::{Ok, Err};
@ -241,14 +241,14 @@ use slice;
/// See the [`std::result`](index.html) module documentation for details.
#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Show, Hash)]
#[must_use]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub enum Result<T, E> {
/// Contains the success value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
Ok(T),
/// Contains the error value
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
Err(E)
}
@ -256,7 +256,7 @@ pub enum Result<T, E> {
// Type implementation
/////////////////////////////////////////////////////////////////////////////
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T, E> Result<T, E> {
/////////////////////////////////////////////////////////////////////////
// Querying the contained values
@ -274,7 +274,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.is_ok(), false);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_ok(&self) -> bool {
match *self {
Ok(_) => true,
@ -294,7 +294,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.is_err(), true);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn is_err(&self) -> bool {
!self.is_ok()
}
@ -318,7 +318,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.ok(), None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn ok(self) -> Option<T> {
match self {
Ok(x) => Some(x),
@ -341,7 +341,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.err(), Some("Nothing here"));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn err(self) -> Option<E> {
match self {
Ok(_) => None,
@ -366,7 +366,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.as_ref(), Err(&"Error"));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn as_ref(&self) -> Result<&T, &E> {
match *self {
Ok(ref x) => Ok(x),
@ -393,7 +393,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.unwrap_err(), 0);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn as_mut(&mut self) -> Result<&mut T, &mut E> {
match *self {
Ok(ref mut x) => Ok(x),
@ -417,7 +417,8 @@ impl<T, E> Result<T, E> {
/// assert!(x.as_mut_slice().is_empty());
/// ```
#[inline]
#[unstable = "waiting for mut conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "waiting for mut conventions")]
pub fn as_mut_slice(&mut self) -> &mut [T] {
match *self {
Ok(ref mut x) => slice::mut_ref_slice(x),
@ -463,7 +464,7 @@ impl<T, E> Result<T, E> {
/// assert!(sum == 10);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Result<U,E> {
match self {
Ok(t) => Ok(op(t)),
@ -489,7 +490,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.map_err(stringify), Err("error code: 13".to_string()));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn map_err<F, O: FnOnce(E) -> F>(self, op: O) -> Result<T,F> {
match self {
Ok(t) => Ok(t),
@ -513,7 +514,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.iter().next(), None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
Iter { inner: self.as_ref().ok() }
}
@ -534,7 +535,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.iter_mut().next(), None);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn iter_mut(&mut self) -> IterMut<T> {
IterMut { inner: self.as_mut().ok() }
}
@ -553,7 +554,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(v, vec![]);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<T> {
IntoIter { inner: self.ok() }
}
@ -584,7 +585,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.and(y), Ok("different result type"));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn and<U>(self, res: Result<U, E>) -> Result<U, E> {
match self {
Ok(_) => res,
@ -608,7 +609,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(Err(3).and_then(sq).and_then(sq), Err(3));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E> {
match self {
Ok(t) => op(t),
@ -638,7 +639,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.or(y), Ok(2));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn or(self, res: Result<T, E>) -> Result<T, E> {
match self {
Ok(_) => self,
@ -662,7 +663,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(Err(3).or_else(err).or_else(err), Err(3));
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F> {
match self {
Ok(t) => Ok(t),
@ -684,7 +685,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(x.unwrap_or(optb), optb);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn unwrap_or(self, optb: T) -> T {
match self {
Ok(t) => t,
@ -704,7 +705,7 @@ impl<T, E> Result<T, E> {
/// assert_eq!(Err("foo").unwrap_or_else(count), 3u);
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn unwrap_or_else<F: FnOnce(E) -> T>(self, op: F) -> T {
match self {
Ok(t) => t,
@ -713,7 +714,7 @@ impl<T, E> Result<T, E> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T, E: Show> Result<T, E> {
/// Unwraps a result, yielding the content of an `Ok`.
///
@ -734,7 +735,7 @@ impl<T, E: Show> Result<T, E> {
/// x.unwrap(); // panics with `emergency failure`
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn unwrap(self) -> T {
match self {
Ok(t) => t,
@ -744,7 +745,7 @@ impl<T, E: Show> Result<T, E> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Show, E> Result<T, E> {
/// Unwraps a result, yielding the content of an `Err`.
///
@ -765,7 +766,7 @@ impl<T: Show, E> Result<T, E> {
/// assert_eq!(x.unwrap_err(), "emergency failure");
/// ```
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn unwrap_err(self) -> E {
match self {
Ok(t) =>
@ -782,7 +783,7 @@ impl<T: Show, E> Result<T, E> {
impl<T, E> AsSlice<T> for Result<T, E> {
/// Convert from `Result<T, E>` to `&[T]` (without copying)
#[inline]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn as_slice<'a>(&'a self) -> &'a [T] {
match *self {
Ok(ref x) => slice::ref_slice(x),
@ -800,10 +801,10 @@ impl<T, E> AsSlice<T> for Result<T, E> {
/////////////////////////////////////////////////////////////////////////////
/// An iterator over a reference to the `Ok` variant of a `Result`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Iter<'a, T: 'a> { inner: Option<&'a T> }
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
@ -816,13 +817,13 @@ impl<'a, T> Iterator for Iter<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a T> { self.inner.take() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
impl<'a, T> Clone for Iter<'a, T> {
@ -830,10 +831,10 @@ impl<'a, T> Clone for Iter<'a, T> {
}
/// An iterator over a mutable reference to the `Ok` variant of a `Result`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IterMut<'a, T: 'a> { inner: Option<&'a mut T> }
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
@ -846,20 +847,20 @@ impl<'a, T> Iterator for IterMut<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a mut T> { self.inner.take() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
/// An iterator over the value in a `Ok` variant of a `Result`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IntoIter<T> { inner: Option<T> }
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> Iterator for IntoIter<T> {
type Item = T;
@ -872,20 +873,20 @@ impl<T> Iterator for IntoIter<T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> DoubleEndedIterator for IntoIter<T> {
#[inline]
fn next_back(&mut self) -> Option<T> { self.inner.take() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T> ExactSizeIterator for IntoIter<T> {}
/////////////////////////////////////////////////////////////////////////////
// FromIterator
/////////////////////////////////////////////////////////////////////////////
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
/// Takes each element in the `Iterator`: if it is an `Err`, no further
/// elements are taken, and the `Err` is returned. Should no `Err` occur, a
@ -949,7 +950,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
/// If an `Err` is encountered, it is immediately returned.
/// Otherwise, the folded value is returned.
#[inline]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn fold<T,
V,
E,

20
src/libcore/simd.rs
View File

@ -37,7 +37,7 @@
#![allow(non_camel_case_types)]
#![allow(missing_docs)]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
@ -46,26 +46,26 @@ pub struct i8x16(pub i8, pub i8, pub i8, pub i8,
pub i8, pub i8, pub i8, pub i8,
pub i8, pub i8, pub i8, pub i8);
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct i16x8(pub i16, pub i16, pub i16, pub i16,
pub i16, pub i16, pub i16, pub i16);
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct i32x4(pub i32, pub i32, pub i32, pub i32);
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct i64x2(pub i64, pub i64);
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
@ -74,32 +74,32 @@ pub struct u8x16(pub u8, pub u8, pub u8, pub u8,
pub u8, pub u8, pub u8, pub u8,
pub u8, pub u8, pub u8, pub u8);
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct u16x8(pub u16, pub u16, pub u16, pub u16,
pub u16, pub u16, pub u16, pub u16);
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct u32x4(pub u32, pub u32, pub u32, pub u32);
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct u64x2(pub u64, pub u64);
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]
pub struct f32x4(pub f32, pub f32, pub f32, pub f32);
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
#[simd]
#[derive(Copy, Show)]
#[repr(C)]

135
src/libcore/slice.rs
View File

@ -12,7 +12,7 @@
//!
//! For more details `std::slice`.
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
#![doc(primitive = "slice")]
// How this module is organized.
@ -131,7 +131,7 @@ pub trait SliceExt {
fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<T> SliceExt for [T] {
type Item = T;
@ -258,7 +258,7 @@ impl<T> SliceExt for [T] {
self.repr().data
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
fn binary_search_by<F>(&self, mut f: F) -> Result<uint, uint> where
F: FnMut(&T) -> Ordering
{
@ -452,12 +452,12 @@ impl<T> SliceExt for [T] {
m >= n && needle == &self[(m-n)..]
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
fn binary_search(&self, x: &T) -> Result<uint, uint> where T: Ord {
self.binary_search_by(|p| p.cmp(x))
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
fn next_permutation(&mut self) -> bool where T: Ord {
// These cases only have 1 permutation each, so we can't do anything.
if self.len() < 2 { return false; }
@ -488,7 +488,7 @@ impl<T> SliceExt for [T] {
true
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
fn prev_permutation(&mut self) -> bool where T: Ord {
// These cases only have 1 permutation each, so we can't do anything.
if self.len() < 2 { return false; }
@ -630,33 +630,34 @@ impl<T> ops::IndexMut<ops::FullRange> for [T] {
////////////////////////////////////////////////////////////////////////////////
/// Data that is viewable as a slice.
#[unstable = "will be replaced by slice syntax"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will be replaced by slice syntax")]
pub trait AsSlice<T> {
/// Work with `self` as a slice.
fn as_slice<'a>(&'a self) -> &'a [T];
}
#[unstable = "trait is experimental"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")]
impl<T> AsSlice<T> for [T] {
#[inline(always)]
fn as_slice<'a>(&'a self) -> &'a [T] { self }
}
#[unstable = "trait is experimental"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")]
impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a U {
#[inline(always)]
fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
}
#[unstable = "trait is experimental"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")]
impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a mut U {
#[inline(always)]
fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Default for &'a [T] {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> &'a [T] { &[] }
}
@ -667,7 +668,7 @@ impl<'a, T> Default for &'a [T] {
// The shared definition of the `Iter` and `IterMut` iterators
macro_rules! iterator {
(struct $name:ident -> $ptr:ty, $elem:ty) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for $name<'a, T> {
type Item = $elem;
@ -705,7 +706,7 @@ macro_rules! iterator {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for $name<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<$elem> {
@ -747,14 +748,14 @@ macro_rules! make_slice {
}
/// Immutable slice iterator
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Iter<'a, T: 'a> {
ptr: *const T,
end: *const T,
marker: marker::ContravariantLifetime<'a>
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> {
type Output = [T];
#[inline]
@ -763,7 +764,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> {
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
type Output = [T];
#[inline]
@ -772,7 +773,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
type Output = [T];
#[inline]
@ -781,7 +782,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
type Output = [T];
#[inline]
@ -795,7 +796,7 @@ impl<'a, T> Iter<'a, T> {
///
/// This has the same lifetime as the original slice, and so the
/// iterator can continue to be used while this exists.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn as_slice(&self) -> &'a [T] {
make_slice!(T => &'a [T]: self.ptr, self.end)
}
@ -805,15 +806,15 @@ impl<'a,T> Copy for Iter<'a,T> {}
iterator!{struct Iter -> *const T, &'a T}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Clone for Iter<'a, T> {
fn clone(&self) -> Iter<'a, T> { *self }
}
#[unstable = "trait is experimental"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")]
impl<'a, T> RandomAccessIterator for Iter<'a, T> {
#[inline]
fn indexable(&self) -> uint {
@ -839,7 +840,7 @@ impl<'a, T> RandomAccessIterator for Iter<'a, T> {
}
/// Mutable slice iterator.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct IterMut<'a, T: 'a> {
ptr: *mut T,
end: *mut T,
@ -847,7 +848,7 @@ pub struct IterMut<'a, T: 'a> {
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -855,7 +856,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
self.index(&ops::FullRange).index(index)
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -863,7 +864,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {
self.index(&ops::FullRange).index(index)
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -871,7 +872,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {
self.index(&ops::FullRange).index(index)
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -880,7 +881,7 @@ impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -888,7 +889,7 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
self.index_mut(&ops::FullRange).index_mut(index)
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -896,7 +897,7 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
self.index_mut(&ops::FullRange).index_mut(index)
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -904,7 +905,7 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
self.index_mut(&ops::FullRange).index_mut(index)
}
}
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> {
type Output = [T];
#[inline]
@ -921,7 +922,7 @@ impl<'a, T> IterMut<'a, T> {
/// to consume the iterator. Consider using the `Slice` and
/// `SliceMut` implementations for obtaining slices with more
/// restricted lifetimes that do not consume the iterator.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn into_slice(self) -> &'a mut [T] {
make_slice!(T => &'a mut [T]: self.ptr, self.end)
}
@ -929,7 +930,7 @@ impl<'a, T> IterMut<'a, T> {
iterator!{struct IterMut -> *mut T, &'a mut T}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
/// An internal abstraction over the splitting iterators, so that
@ -942,7 +943,7 @@ trait SplitIter: DoubleEndedIterator {
/// An iterator over subslices separated by elements that match a predicate
/// function.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Split<'a, T:'a, P> where P: FnMut(&T) -> bool {
v: &'a [T],
pred: P,
@ -950,7 +951,7 @@ pub struct Split<'a, T:'a, P> where P: FnMut(&T) -> bool {
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, P> Clone for Split<'a, T, P> where P: Clone + FnMut(&T) -> bool {
fn clone(&self) -> Split<'a, T, P> {
Split {
@ -961,7 +962,7 @@ impl<'a, T, P> Clone for Split<'a, T, P> where P: Clone + FnMut(&T) -> bool {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
type Item = &'a [T];
@ -989,7 +990,7 @@ impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
#[inline]
fn next_back(&mut self) -> Option<&'a [T]> {
@ -1015,7 +1016,7 @@ impl<'a, T, P> SplitIter for Split<'a, T, P> where P: FnMut(&T) -> bool {
/// An iterator over the subslices of the vector which are separated
/// by elements that match `pred`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct SplitMut<'a, T:'a, P> where P: FnMut(&T) -> bool {
v: &'a mut [T],
pred: P,
@ -1034,7 +1035,7 @@ impl<'a, T, P> SplitIter for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
type Item = &'a mut [T];
@ -1069,7 +1070,7 @@ impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P> where
P: FnMut(&T) -> bool,
{
@ -1124,7 +1125,7 @@ impl<T, I: SplitIter<Item=T>> Iterator for GenericSplitN<I> {
/// An iterator over subslices separated by elements that match a predicate
/// function, limited to a given number of splits.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct SplitN<'a, T: 'a, P> where P: FnMut(&T) -> bool {
inner: GenericSplitN<Split<'a, T, P>>
}
@ -1132,14 +1133,14 @@ pub struct SplitN<'a, T: 'a, P> where P: FnMut(&T) -> bool {
/// An iterator over subslices separated by elements that match a
/// predicate function, limited to a given number of splits, starting
/// from the end of the slice.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct RSplitN<'a, T: 'a, P> where P: FnMut(&T) -> bool {
inner: GenericSplitN<Split<'a, T, P>>
}
/// An iterator over subslices separated by elements that match a predicate
/// function, limited to a given number of splits.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct SplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {
inner: GenericSplitN<SplitMut<'a, T, P>>
}
@ -1147,14 +1148,14 @@ pub struct SplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {
/// An iterator over subslices separated by elements that match a
/// predicate function, limited to a given number of splits, starting
/// from the end of the slice.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct RSplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {
inner: GenericSplitN<SplitMut<'a, T, P>>
}
macro_rules! forward_iterator {
($name:ident: $elem:ident, $iter_of:ty) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, $elem, P> Iterator for $name<'a, $elem, P> where
P: FnMut(&T) -> bool
{
@ -1180,13 +1181,13 @@ forward_iterator! { RSplitNMut: T, &'a mut [T] }
/// An iterator over overlapping subslices of length `size`.
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Windows<'a, T:'a> {
v: &'a [T],
size: uint
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for Windows<'a, T> {
type Item = &'a [T];
@ -1218,13 +1219,13 @@ impl<'a, T> Iterator for Windows<'a, T> {
/// When the slice len is not evenly divided by the chunk size, the last slice
/// of the iteration will be the remainder.
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Chunks<'a, T:'a> {
v: &'a [T],
size: uint
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for Chunks<'a, T> {
type Item = &'a [T];
@ -1253,7 +1254,7 @@ impl<'a, T> Iterator for Chunks<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a [T]> {
@ -1269,7 +1270,7 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
}
}
#[unstable = "trait is experimental"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")]
impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
#[inline]
fn indexable(&self) -> uint {
@ -1293,13 +1294,13 @@ impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
/// An iterator over a slice in (non-overlapping) mutable chunks (`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.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct ChunksMut<'a, T:'a> {
v: &'a mut [T],
chunk_size: uint
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> Iterator for ChunksMut<'a, T> {
type Item = &'a mut [T];
@ -1329,7 +1330,7 @@ impl<'a, T> Iterator for ChunksMut<'a, T> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a mut [T]> {
@ -1353,7 +1354,7 @@ impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
//
/// Converts a pointer to A into a slice of length 1 (without copying).
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
unsafe {
transmute(RawSlice { data: s, len: 1 })
@ -1361,7 +1362,7 @@ pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
}
/// Converts a pointer to A into a slice of length 1 (without copying).
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
unsafe {
let ptr: *const A = transmute(s);
@ -1395,7 +1396,8 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
/// }
/// ```
#[inline]
#[unstable = "should be renamed to from_raw_parts"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "should be renamed to from_raw_parts")]
pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
transmute(RawSlice { data: *p, len: len })
}
@ -1407,7 +1409,8 @@ pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
/// not being able to provide a non-aliasing guarantee of the returned mutable
/// slice.
#[inline]
#[unstable = "should be renamed to from_raw_parts_mut"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "should be renamed to from_raw_parts_mut")]
pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
transmute(RawSlice { data: *p, len: len })
}
@ -1417,7 +1420,7 @@ pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
//
/// Operations on `[u8]`.
#[unstable = "needs review"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "needs review")]
pub mod bytes {
use ptr;
use slice::SliceExt;
@ -1459,7 +1462,7 @@ pub mod bytes {
// Boilerplate traits
//
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<A, B> PartialEq<[B]> for [A] where A: PartialEq<B> {
fn eq(&self, other: &[B]) -> bool {
self.len() == other.len() &&
@ -1471,17 +1474,17 @@ impl<A, B> PartialEq<[B]> for [A] where A: PartialEq<B> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Eq> Eq for [T] {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: Ord> Ord for [T] {
fn cmp(&self, other: &[T]) -> Ordering {
order::cmp(self.iter(), other.iter())
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<T: PartialOrd> PartialOrd for [T] {
#[inline]
fn partial_cmp(&self, other: &[T]) -> Option<Ordering> {
@ -1506,7 +1509,7 @@ impl<T: PartialOrd> PartialOrd for [T] {
}
/// Extension methods for slices containing integers.
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub trait IntSliceExt<U, S> {
/// Converts the slice to an immutable slice of unsigned integers with the same width.
fn as_unsigned<'a>(&'a self) -> &'a [U];
@ -1521,7 +1524,7 @@ pub trait IntSliceExt<U, S> {
macro_rules! impl_int_slice {
($u:ty, $s:ty, $t:ty) => {
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
impl IntSliceExt<$u, $s> for [$t] {
#[inline]
fn as_unsigned(&self) -> &[$u] { unsafe { transmute(self) } }

97
src/libcore/str/mod.rs
View File

@ -45,7 +45,7 @@ macro_rules! delegate_iter {
}
};
($te:ty : $ti:ty) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for $ti {
type Item = $te;
@ -58,7 +58,7 @@ macro_rules! delegate_iter {
self.0.size_hint()
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> DoubleEndedIterator for $ti {
#[inline]
fn next_back(&mut self) -> Option<$te> {
@ -67,7 +67,7 @@ macro_rules! delegate_iter {
}
};
(pattern $te:ty : $ti:ty) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, P: CharEq> Iterator for $ti {
type Item = $te;
@ -80,7 +80,7 @@ macro_rules! delegate_iter {
self.0.size_hint()
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, P: CharEq> DoubleEndedIterator for $ti {
#[inline]
fn next_back(&mut self) -> Option<$te> {
@ -89,7 +89,7 @@ macro_rules! delegate_iter {
}
};
(pattern forward $te:ty : $ti:ty) => {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, P: CharEq> Iterator for $ti {
type Item = $te;
@ -108,7 +108,8 @@ macro_rules! delegate_iter {
/// A trait to abstract the idea of creating a new instance of a type from a
/// string.
// FIXME(#17307): there should be an `E` associated type for a `Result` return
#[unstable = "will return a Result once associated types are working"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "will return a Result once associated types are working")]
pub trait FromStr {
/// Parses a string `s` to return an optional value of this type. If the
/// string is ill-formatted, the None is returned.
@ -143,7 +144,8 @@ Section: Creating a string
/// Errors which can occur when attempting to interpret a byte slice as a `str`.
#[derive(Copy, Eq, PartialEq, Clone, Show)]
#[unstable = "error enumeration recently added and definitions may be refined"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "error enumeration recently added and definitions may be refined")]
pub enum Utf8Error {
/// An invalid byte was detected at the byte offset given.
///
@ -167,7 +169,7 @@ pub enum Utf8Error {
///
/// Returns `Err` if the slice is not utf-8 with a description as to why the
/// provided slice is not utf-8.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {
try!(run_utf8_validation_iterator(&mut v.iter()));
Ok(unsafe { from_utf8_unchecked(v) })
@ -175,7 +177,7 @@ pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {
/// Converts a slice of bytes to a string slice without checking
/// that the string contains valid UTF-8.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub unsafe fn from_utf8_unchecked<'a>(v: &'a [u8]) -> &'a str {
mem::transmute(v)
}
@ -193,7 +195,8 @@ pub unsafe fn from_utf8_unchecked<'a>(v: &'a [u8]) -> &'a str {
/// # Panics
///
/// This function will panic if the string pointed to by `s` is not valid UTF-8.
#[deprecated = "use std::ffi::c_str_to_bytes + str::from_utf8"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use std::ffi::c_str_to_bytes + str::from_utf8")]
pub unsafe fn from_c_str(s: *const i8) -> &'static str {
let s = s as *const u8;
let mut len = 0u;
@ -205,7 +208,8 @@ pub unsafe fn from_c_str(s: *const i8) -> &'static str {
}
/// Something that can be used to compare against a character
#[unstable = "definition may change as pattern-related methods are stabilized"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "definition may change as pattern-related methods are stabilized")]
pub trait CharEq {
/// Determine if the splitter should split at the given character
fn matches(&mut self, char) -> bool;
@ -250,7 +254,7 @@ Section: Iterators
///
/// Created with the method `.chars()`.
#[derive(Clone, Copy)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Chars<'a> {
iter: slice::Iter<'a, u8>
}
@ -279,7 +283,7 @@ fn unwrap_or_0(opt: Option<&u8>) -> u8 {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for Chars<'a> {
type Item = char;
@ -325,7 +329,7 @@ impl<'a> Iterator for Chars<'a> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> DoubleEndedIterator for Chars<'a> {
#[inline]
fn next_back(&mut self) -> Option<char> {
@ -362,13 +366,13 @@ impl<'a> DoubleEndedIterator for Chars<'a> {
/// External iterator for a string's characters and their byte offsets.
/// Use with the `std::iter` module.
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct CharIndices<'a> {
front_offset: uint,
iter: Chars<'a>,
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for CharIndices<'a> {
type Item = (uint, char);
@ -392,7 +396,7 @@ impl<'a> Iterator for CharIndices<'a> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> DoubleEndedIterator for CharIndices<'a> {
#[inline]
fn next_back(&mut self) -> Option<(uint, char)> {
@ -411,7 +415,7 @@ impl<'a> DoubleEndedIterator for CharIndices<'a> {
/// Use with the `std::iter` module.
///
/// Created with `StrExt::bytes`
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[derive(Clone)]
pub struct Bytes<'a>(Map<&'a u8, u8, slice::Iter<'a, u8>, BytesDeref>);
delegate_iter!{exact u8 : Bytes<'a>}
@ -451,13 +455,13 @@ struct CharSplitsN<'a, Sep> {
}
/// An iterator over the lines of a string, separated by `\n`.
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Lines<'a> {
inner: CharSplits<'a, char>,
}
/// An iterator over the lines of a string, separated by either `\n` or (`\r\n`).
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct LinesAny<'a> {
inner: Map<&'a str, &'a str, Lines<'a>, fn(&str) -> &str>,
}
@ -474,7 +478,7 @@ impl<'a, Sep> CharSplits<'a, Sep> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
type Item = &'a str;
@ -509,7 +513,7 @@ impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
#[inline]
fn next_back(&mut self) -> Option<&'a str> {
@ -551,7 +555,7 @@ impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a, Sep: CharEq> Iterator for CharSplitsN<'a, Sep> {
type Item = &'a str;
@ -857,7 +861,7 @@ impl Searcher {
/// An iterator over the start and end indices of the matches of a
/// substring within a larger string
#[derive(Clone)]
#[unstable = "type may be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "type may be removed")]
pub struct MatchIndices<'a> {
// constants
haystack: &'a str,
@ -868,14 +872,14 @@ pub struct MatchIndices<'a> {
/// An iterator over the substrings of a string separated by a given
/// search string
#[derive(Clone)]
#[unstable = "type may be removed"]
#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "type may be removed")]
pub struct SplitStr<'a> {
it: MatchIndices<'a>,
last_end: uint,
finished: bool
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for MatchIndices<'a> {
type Item = (uint, uint);
@ -892,7 +896,7 @@ impl<'a> Iterator for MatchIndices<'a> {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for SplitStr<'a> {
type Item = &'a str;
@ -1052,7 +1056,8 @@ static UTF8_CHAR_WIDTH: [u8; 256] = [
/// the next `char` in a string. This can be used as a data structure
/// for iterating over the UTF-8 bytes of a string.
#[derive(Copy)]
#[unstable = "naming is uncertain with container conventions"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "naming is uncertain with container conventions")]
pub struct CharRange {
/// Current `char`
pub ch: char,
@ -1078,7 +1083,7 @@ mod traits {
use ops;
use str::{StrExt, eq_slice};
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Ord for str {
#[inline]
fn cmp(&self, other: &str) -> Ordering {
@ -1094,7 +1099,7 @@ mod traits {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialEq for str {
#[inline]
fn eq(&self, other: &str) -> bool {
@ -1104,10 +1109,10 @@ mod traits {
fn ne(&self, other: &str) -> bool { !(*self).eq(other) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Eq for str {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl PartialOrd for str {
#[inline]
fn partial_cmp(&self, other: &str) -> Option<Ordering> {
@ -1146,9 +1151,10 @@ mod traits {
}
/// Any string that can be represented as a slice
#[unstable = "Instead of taking this bound generically, this trait will be \
replaced with one of slicing syntax, deref coercions, or \
a more generic conversion trait"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "Instead of taking this bound generically, this trait will be \
replaced with one of slicing syntax, deref coercions, or \
a more generic conversion trait")]
pub trait Str {
/// Work with `self` as a slice.
fn as_slice<'a>(&'a self) -> &'a str;
@ -1166,25 +1172,26 @@ impl<'a, S: ?Sized> Str for &'a S where S: Str {
/// Return type of `StrExt::split`
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct Split<'a, P>(CharSplits<'a, P>);
delegate_iter!{pattern &'a str : Split<'a, P>}
/// Return type of `StrExt::split_terminator`
#[derive(Clone)]
#[unstable = "might get removed in favour of a constructor method on Split"]
#[unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "might get removed in favour of a constructor method on Split")]
pub struct SplitTerminator<'a, P>(CharSplits<'a, P>);
delegate_iter!{pattern &'a str : SplitTerminator<'a, P>}
/// Return type of `StrExt::splitn`
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct SplitN<'a, P>(CharSplitsN<'a, P>);
delegate_iter!{pattern forward &'a str : SplitN<'a, P>}
/// Return type of `StrExt::rsplitn`
#[derive(Clone)]
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
pub struct RSplitN<'a, P>(CharSplitsN<'a, P>);
delegate_iter!{pattern forward &'a str : RSplitN<'a, P>}
@ -1599,13 +1606,13 @@ impl StrExt for str {
fn parse<T: FromStr>(&self) -> Option<T> { FromStr::from_str(self) }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Default for &'a str {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> &'a str { "" }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for Lines<'a> {
type Item = &'a str;
@ -1615,13 +1622,13 @@ impl<'a> Iterator for Lines<'a> {
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> DoubleEndedIterator for Lines<'a> {
#[inline]
fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> Iterator for LinesAny<'a> {
type Item = &'a str;
@ -1631,7 +1638,7 @@ impl<'a> Iterator for LinesAny<'a> {
fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<'a> DoubleEndedIterator for LinesAny<'a> {
#[inline]
fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }

16
src/libcore/tuple.rs
View File

@ -33,7 +33,7 @@
//! * `Ord`
//! * `Default`
#![stable]
#![stable(feature = "grandfathered", since = "1.0.0")]
use clone::Clone;
use cmp::*;
@ -55,14 +55,14 @@ macro_rules! tuple_impls {
}
)+) => {
$(
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<$($T:Clone),+> Clone for ($($T,)+) {
fn clone(&self) -> ($($T,)+) {
($(e!(self.$idx.clone()),)+)
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<$($T:PartialEq),+> PartialEq for ($($T,)+) {
#[inline]
fn eq(&self, other: &($($T,)+)) -> bool {
@ -74,10 +74,10 @@ macro_rules! tuple_impls {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<$($T:Eq),+> Eq for ($($T,)+) {}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<$($T:PartialOrd + PartialEq),+> PartialOrd for ($($T,)+) {
#[inline]
fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
@ -101,7 +101,7 @@ macro_rules! tuple_impls {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<$($T:Ord),+> Ord for ($($T,)+) {
#[inline]
fn cmp(&self, other: &($($T,)+)) -> Ordering {
@ -109,9 +109,9 @@ macro_rules! tuple_impls {
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl<$($T:Default),+> Default for ($($T,)+) {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
#[inline]
fn default() -> ($($T,)+) {
($({ let x: $T = Default::default(); x},)+)

2
src/libflate/lib.rs
View File

@ -15,7 +15,7 @@
//! [mz]: https://code.google.com/p/miniz/
#![crate_name = "flate"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![allow(unknown_features)] #![feature(int_uint)]
#![allow(unstable)]

2
src/libfmt_macros/lib.rs
View File

@ -15,7 +15,7 @@
//! generated instead.
#![crate_name = "fmt_macros"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "rlib"]
#![crate_type = "dylib"]

6
src/libgetopts/lib.rs
View File

@ -78,7 +78,8 @@
//! ```
#![crate_name = "getopts"]
#![unstable = "use the crates.io `getopts` library instead"]
#![unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "use the crates.io `getopts` library instead")]
#![staged_api]
#![crate_type = "rlib"]
#![crate_type = "dylib"]
@ -538,7 +539,8 @@ pub fn opt(short_name: &str,
impl Fail {
/// Convert a `Fail` enum into an error string.
#[deprecated="use `fmt::String` (`{}` format specifier)"]
#[deprecated(feature = "oldstuff", since = "1.0.0",
reason = "use `fmt::String` (`{}` format specifier)")]
pub fn to_err_msg(self) -> String {
self.to_string()
}

2
src/libgraphviz/lib.rs
View File

@ -265,7 +265,7 @@
//! * [DOT language](http://www.graphviz.org/doc/info/lang.html)
#![crate_name = "graphviz"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "rlib"]
#![crate_type = "dylib"]

2
src/libgraphviz/maybe_owned_vec.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![deprecated = "use std::vec::CowVec"]
#![deprecated(feature = "oldstuff", since = "1.0.0", reason = "use std::vec::CowVec")]
pub use self::MaybeOwnedVector::*;

3
src/liblibc/lib.rs
View File

@ -10,7 +10,8 @@
#![crate_name = "libc"]
#![crate_type = "rlib"]
#![cfg_attr(not(feature = "cargo-build"), unstable)]
#![cfg_attr(not(feature = "cargo-build"),
unstable(feature = "unnamed_feature", since = "1.0.0"))]
#![cfg_attr(not(feature = "cargo-build"), staged_api)]
#![allow(unknown_features)] #![feature(int_uint)]
#![allow(unstable)]

3
src/liblog/lib.rs
View File

@ -156,7 +156,8 @@
//! if logging is disabled, none of the components of the log will be executed.
#![crate_name = "log"]
#![unstable = "use the crates.io `log` library instead"]
#![unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "use the crates.io `log` library instead")]
#![staged_api]
#![crate_type = "rlib"]
#![crate_type = "dylib"]

2
src/librand/distributions/mod.rs
View File

@ -17,7 +17,7 @@
//! internally. The `IndependentSample` trait is for generating values
//! that do not need to record state.
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
use core::prelude::*;
use core::num::{Float, Int};

2
src/librand/lib.rs
View File

@ -25,7 +25,7 @@
#![allow(unknown_features)] #![feature(int_uint)]
#![allow(unstable)]
#![no_std]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#[macro_use]

4
src/librand/reseeding.rs
View File

@ -141,9 +141,9 @@ impl<R: Rng + Default> Reseeder<R> for ReseedWithDefault {
*rng = Default::default();
}
}
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
impl Default for ReseedWithDefault {
#[stable]
#[stable(feature = "grandfathered", since = "1.0.0")]
fn default() -> ReseedWithDefault { ReseedWithDefault }
}

2
src/librbml/lib.rs
View File

@ -16,7 +16,7 @@
//! http://www.matroska.org/technical/specs/rfc/index.html
#![crate_name = "rbml"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "rlib"]
#![crate_type = "dylib"]

3
src/libregex/lib.rs
View File

@ -16,7 +16,8 @@
#![crate_name = "regex"]
#![crate_type = "rlib"]
#![crate_type = "dylib"]
#![unstable = "use the crates.io `regex` library instead"]
#![unstable(feature = "unnamed_feature", since = "1.0.0",
reason = "use the crates.io `regex` library instead")]
#![staged_api]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",

2
src/libregex/re.rs
View File

@ -255,7 +255,7 @@ impl Regex {
}
#[doc(hidden)]
#[unstable]
#[unstable(feature = "unnamed_feature", since = "1.0.0")]
pub fn names_iter<'a>(&'a self) -> NamesIter<'a> {
match *self {
Native(ref n) => NamesIterNative(n.names.iter()),

2
src/librustc/lib.rs
View File

@ -15,7 +15,7 @@
//! This API is completely unstable and subject to change.
#![crate_name = "rustc"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

28
src/librustc/lint/builtin.rs
View File

@ -1637,19 +1637,15 @@ declare_lint! {
/// Checks for use of items with `#[deprecated]`, `#[unstable]` and
/// `#[unstable]` attributes, or no stability attribute.
#[derive(Copy)]
pub struct Stability { this_crate_staged: bool }
pub struct Stability;
impl Stability {
pub fn new() -> Stability { Stability { this_crate_staged: false } }
fn lint(&self, cx: &Context, id: ast::DefId, span: Span) {
if !stability::is_staged_api(cx.tcx, id) { return }
let ref stability = stability::lookup(cx.tcx, id);
let cross_crate = !ast_util::is_local(id);
let staged = (!cross_crate && self.this_crate_staged)
|| (cross_crate && stability::is_staged_api(cx.tcx, id));
if !staged { return }
// stability attributes are promises made across crates; only
// check DEPRECATED for crate-local usage.
@ -1668,7 +1664,7 @@ impl Stability {
fn output(cx: &Context, span: Span, stability: &Option<attr::Stability>,
lint: &'static Lint, label: &'static str) {
let msg = match *stability {
Some(attr::Stability { text: Some(ref s), .. }) => {
Some(attr::Stability { reason: Some(ref s), .. }) => {
format!("use of {} item: {}", label, *s)
}
_ => format!("use of {} item", label)
@ -1690,22 +1686,6 @@ impl LintPass for Stability {
lint_array!(DEPRECATED, UNSTABLE)
}
fn check_crate(&mut self, _: &Context, c: &ast::Crate) {
// Just mark the #[staged_api] attribute used, though nothing else is done
// with it during this pass over the source.
for attr in c.attrs.iter() {
if attr.name().get() == "staged_api" {
match attr.node.value.node {
ast::MetaWord(_) => {
attr::mark_used(attr);
self.this_crate_staged = true;
}
_ => (/*pass*/)
}
}
}
}
fn check_view_item(&mut self, cx: &Context, item: &ast::ViewItem) {
// compiler-generated `extern crate` statements have a dummy span.
if item.span == DUMMY_SP { return }

2
src/librustc/lint/context.rs
View File

@ -211,13 +211,13 @@ impl LintStore {
UnusedAllocation,
MissingCopyImplementations,
UnstableFeatures,
Stability,
);
add_builtin_with_new!(sess,
TypeLimits,
RawPointerDerive,
MissingDoc,
Stability,
);
add_lint_group!(sess, "bad_style",

47
src/librustc/middle/stability.rs
View File

@ -11,6 +11,7 @@
//! A pass that annotates every item and method with its stability level,
//! propagating default levels lexically from parent to children ast nodes.
use session::Session;
use middle::ty;
use metadata::csearch;
use syntax::codemap::Span;
@ -20,7 +21,7 @@ use syntax::ast::{Attribute, Block, Crate, DefId, FnDecl, NodeId, Variant};
use syntax::ast::{Item, RequiredMethod, ProvidedMethod, TraitItem};
use syntax::ast::{TypeMethod, Method, Generics, StructField, TypeTraitItem};
use syntax::ast_util::is_local;
use syntax::attr::Stability;
use syntax::attr::{Stability, AttrMetaMethods};
use syntax::visit::{FnKind, FkMethod, Visitor};
use util::nodemap::{NodeMap, DefIdMap};
use util::ppaux::Repr;
@ -29,6 +30,8 @@ use std::mem::replace;
/// A stability index, giving the stability level for items and methods.
pub struct Index {
// Indicates whether this crate has #![staged_api]
staged_api: bool,
// stability for crate-local items; unmarked stability == no entry
local: NodeMap<Stability>,
// cache for extern-crate items; unmarked stability == entry with None
@ -36,23 +39,24 @@ pub struct Index {
}
// A private tree-walker for producing an Index.
struct Annotator {
struct Annotator<'a> {
sess: &'a Session,
index: Index,
parent: Option<Stability>
}
impl Annotator {
impl<'a> Annotator<'a> {
// Determine the stability for a node based on its attributes and inherited
// stability. The stability is recorded in the index and used as the parent.
fn annotate<F>(&mut self, id: NodeId, use_parent: bool,
attrs: &Vec<Attribute>, f: F) where
F: FnOnce(&mut Annotator),
{
match attr::find_stability(attrs.as_slice()) {
match attr::find_stability(self.sess.diagnostic(), attrs.as_slice()) {
Some(stab) => {
self.index.local.insert(id, stab.clone());
// Don't inherit #[stable]
// Don't inherit #[stable(feature = "grandfathered", since = "1.0.0")]
if stab.level != attr::Stable {
let parent = replace(&mut self.parent, Some(stab));
f(self);
@ -71,7 +75,7 @@ impl Annotator {
}
}
impl<'v> Visitor<'v> for Annotator {
impl<'a, 'v> Visitor<'v> for Annotator<'a> {
fn visit_item(&mut self, i: &Item) {
// FIXME (#18969): the following is a hack around the fact
// that we cannot currently annotate the stability of
@ -138,12 +142,30 @@ impl<'v> Visitor<'v> for Annotator {
impl Index {
/// Construct the stability index for a crate being compiled.
pub fn build(krate: &Crate) -> Index {
pub fn build(sess: &Session, krate: &Crate) -> Index {
let mut staged_api = false;
for attr in krate.attrs.iter() {
if attr.name().get() == "staged_api" {
match attr.node.value.node {
ast::MetaWord(_) => {
attr::mark_used(attr);
staged_api = true;
}
_ => (/*pass*/)
}
}
}
let index = Index {
staged_api: staged_api,
local: NodeMap(),
extern_cache: DefIdMap()
};
if !staged_api {
return index;
}
let mut annotator = Annotator {
index: Index {
local: NodeMap(),
extern_cache: DefIdMap()
},
sess: sess,
index: index,
parent: None
};
annotator.annotate(ast::CRATE_NODE_ID, true, &krate.attrs,
@ -197,8 +219,7 @@ pub fn is_staged_api(tcx: &ty::ctxt, id: DefId) -> bool {
is_staged_api(tcx, trait_method_id)
}
_ if is_local(id) => {
// Unused case
unreachable!()
tcx.stability.borrow().staged_api
}
_ => {
csearch::is_staged_api(&tcx.sess.cstore, id)

2
src/librustc_back/lib.rs
View File

@ -22,7 +22,7 @@
//! build speedups.
#![crate_name = "rustc_back"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

2
src/librustc_bitflags/lib.rs
View File

@ -9,10 +9,10 @@
// except according to those terms.
#![crate_name = "rustc_bitflags"]
#![unstable]
#![staged_api]
#![crate_type = "rlib"]
#![no_std]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
//! A typesafe bitmask flag generator.

2
src/librustc_borrowck/lib.rs
View File

@ -9,7 +9,7 @@
// except according to those terms.
#![crate_name = "rustc_borrowck"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

2
src/librustc_driver/driver.rs
View File

@ -599,7 +599,7 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
middle::check_loop::check_crate(&sess, krate));
let stability_index = time(time_passes, "stability index", (), |_|
stability::Index::build(krate));
stability::Index::build(&sess, krate));
time(time_passes, "static item recursion checking", (), |_|
middle::check_static_recursion::check_crate(&sess, krate, &def_map, &ast_map));

2
src/librustc_driver/lib.rs
View File

@ -15,7 +15,7 @@
//! This API is completely unstable and subject to change.
#![crate_name = "rustc_driver"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

2
src/librustc_driver/test.rs
View File

@ -124,7 +124,7 @@ fn test_env<F>(source_string: &str,
resolve::resolve_crate(&sess, &ast_map, &lang_items, krate, resolve::MakeGlobMap::No);
let named_region_map = resolve_lifetime::krate(&sess, krate, &def_map);
let region_map = region::resolve_crate(&sess, krate);
let stability_index = stability::Index::build(krate);
let stability_index = stability::Index::build(&sess, krate);
let arenas = ty::CtxtArenas::new();
let tcx = ty::mk_ctxt(sess,
&arenas,

2
src/librustc_llvm/lib.rs
View File

@ -14,7 +14,7 @@
#![allow(dead_code)]
#![crate_name = "rustc_llvm"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

2
src/librustc_privacy/lib.rs
View File

@ -9,7 +9,7 @@
// except according to those terms.
#![crate_name = "rustc_privacy"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

2
src/librustc_resolve/lib.rs
View File

@ -9,7 +9,7 @@
// except according to those terms.
#![crate_name = "rustc_resolve"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

2
src/librustc_trans/lib.rs
View File

@ -15,7 +15,7 @@
//! This API is completely unstable and subject to change.
#![crate_name = "rustc_trans"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

2
src/librustc_typeck/lib.rs
View File

@ -64,7 +64,7 @@ This API is completely unstable and subject to change.
*/
#![crate_name = "rustc_typeck"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

13
src/librustdoc/clean/mod.rs
View File

@ -33,6 +33,7 @@ use syntax::ast_util;
use syntax::ast_util::PostExpansionMethod;
use syntax::attr;
use syntax::attr::{AttributeMethods, AttrMetaMethods};
use syntax::codemap;
use syntax::codemap::{DUMMY_SP, Pos, Spanned};
use syntax::parse::token::{self, InternedString, special_idents};
use syntax::ptr::P;
@ -449,11 +450,13 @@ impl attr::AttrMetaMethods for Attribute {
}
}
fn meta_item_list<'a>(&'a self) -> Option<&'a [P<ast::MetaItem>]> { None }
fn span(&self) -> codemap::Span { unimplemented!() }
}
impl<'a> attr::AttrMetaMethods for &'a Attribute {
fn name(&self) -> InternedString { (**self).name() }
fn value_str(&self) -> Option<InternedString> { (**self).value_str() }
fn meta_item_list(&self) -> Option<&[P<ast::MetaItem>]> { None }
fn span(&self) -> codemap::Span { unimplemented!() }
}
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
@ -2483,15 +2486,19 @@ impl Clean<Item> for doctree::Macro {
#[derive(Clone, RustcEncodable, RustcDecodable)]
pub struct Stability {
pub level: attr::StabilityLevel,
pub text: String
pub feature: String,
pub since: String,
pub reason: String
}
impl Clean<Stability> for attr::Stability {
fn clean(&self, _: &DocContext) -> Stability {
Stability {
level: self.level,
text: self.text.as_ref().map_or("".to_string(),
|interned| interned.get().to_string()),
feature: self.feature.get().to_string(),
since: self.since.get().to_string(),
reason: self.reason.as_ref().map_or("".to_string(),
|interned| interned.get().to_string()),
}
}
}

6
src/librustdoc/html/format.rs
View File

@ -714,7 +714,7 @@ impl<'a> fmt::String for Stability<'a> {
Some(ref stability) => {
write!(f, "<a class='stability {lvl}' title='{reason}'>{lvl}</a>",
lvl = stability.level,
reason = stability.text)
reason = stability.reason)
}
None => Ok(())
}
@ -728,8 +728,8 @@ impl<'a> fmt::String for ConciseStability<'a> {
Some(ref stability) => {
write!(f, "<a class='stability {lvl}' title='{lvl}{colon}{reason}'></a>",
lvl = stability.level,
colon = if stability.text.len() > 0 { ": " } else { "" },
reason = stability.text)
colon = if stability.reason.len() > 0 { ": " } else { "" },
reason = stability.reason)
}
None => {
write!(f, "<a class='stability Unmarked' title='No stability level'></a>")

2
src/librustdoc/lib.rs
View File

@ -9,7 +9,7 @@
// except according to those terms.
#![crate_name = "rustdoc"]
#![unstable]
#![unstable(feature = "unnamed_feature", since = "1.0.0")]
#![staged_api]
#![crate_type = "dylib"]
#![crate_type = "rlib"]

Some files were not shown because too many files have changed in this diff Show More