/// on `BinaryHeap`. See its documentation for details.
///
/// [`peek_mut()`]: struct.BinaryHeap.html#method.peek_mut
-#[unstable(feature = "binary_heap_peek_mut", issue = "34392")]
+#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
pub struct PeekMut<'a, T: 'a + Ord> {
heap: &'a mut BinaryHeap<T>
}
-#[unstable(feature = "binary_heap_peek_mut", issue = "34392")]
+#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
impl<'a, T: Ord> Drop for PeekMut<'a, T> {
fn drop(&mut self) {
self.heap.sift_down(0);
}
}
-#[unstable(feature = "binary_heap_peek_mut", issue = "34392")]
+#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
impl<'a, T: Ord> Deref for PeekMut<'a, T> {
type Target = T;
fn deref(&self) -> &T {
}
}
-#[unstable(feature = "binary_heap_peek_mut", issue = "34392")]
+#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
impl<'a, T: Ord> DerefMut for PeekMut<'a, T> {
fn deref_mut(&mut self) -> &mut T {
&mut self.heap.data[0]
/// Basic usage:
///
/// ```
- /// #![feature(binary_heap_peek_mut)]
/// use std::collections::BinaryHeap;
/// let mut heap = BinaryHeap::new();
/// assert!(heap.peek_mut().is_none());
/// }
/// assert_eq!(heap.peek(), Some(&2));
/// ```
- #[unstable(feature = "binary_heap_peek_mut", issue = "34392")]
+ #[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
pub fn peek_mut(&mut self) -> Option<PeekMut<T>> {
if self.is_empty() {
None
/// # Examples
///
/// ```
- /// #![feature(map_entry_recover_keys)]
- ///
/// use std::collections::BTreeMap;
/// use std::collections::btree_map::Entry;
///
/// v.into_key();
/// }
/// ```
- #[unstable(feature = "map_entry_recover_keys", issue = "34285")]
+ #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")]
pub fn into_key(self) -> K {
self.key
}
self.handle.reborrow().into_kv().0
}
+ /// Deprecated, renamed to `remove_entry`
+ #[unstable(feature = "map_entry_recover_keys", issue = "34285")]
+ #[rustc_deprecated(since = "1.12.0", reason = "renamed to `remove_entry`")]
+ pub fn remove_pair(self) -> (K, V) {
+ self.remove_entry()
+ }
+
/// Take ownership of the key and value from the map.
///
/// # Examples
///
/// ```
- /// #![feature(map_entry_recover_keys)]
- ///
/// use std::collections::BTreeMap;
/// use std::collections::btree_map::Entry;
///
///
/// if let Entry::Occupied(o) = map.entry("poneyland") {
/// // We delete the entry from the map.
- /// o.remove_pair();
+ /// o.remove_entry();
/// }
///
/// // If now try to get the value, it will panic:
/// // println!("{}", map["poneyland"]);
/// ```
- #[unstable(feature = "map_entry_recover_keys", issue = "34285")]
- pub fn remove_pair(self) -> (K, V) {
+ #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")]
+ pub fn remove_entry(self) -> (K, V) {
self.remove_kv()
}
/// # Examples
///
/// ```
- /// #![feature(linked_list_contains)]
- ///
/// use std::collections::LinkedList;
///
/// let mut list: LinkedList<u32> = LinkedList::new();
/// assert_eq!(list.contains(&0), true);
/// assert_eq!(list.contains(&10), false);
/// ```
- #[unstable(feature = "linked_list_contains", reason = "recently added",
- issue = "32630")]
+ #[stable(feature = "linked_list_contains", since = "1.12.0")]
pub fn contains(&self, x: &T) -> bool
where T: PartialEq<T>
{
/// # Examples
///
/// ```
- /// #![feature(vec_deque_contains)]
- ///
/// use std::collections::VecDeque;
///
/// let mut vector: VecDeque<u32> = VecDeque::new();
/// assert_eq!(vector.contains(&1), true);
/// assert_eq!(vector.contains(&10), false);
/// ```
- #[unstable(feature = "vec_deque_contains", reason = "recently added",
- issue = "32630")]
+ #[stable(feature = "vec_deque_contains", since = "1.12.0")]
pub fn contains(&self, x: &T) -> bool
where T: PartialEq<T>
{
#![deny(warnings)]
#![feature(binary_heap_extras)]
-#![feature(binary_heap_peek_mut)]
#![feature(box_syntax)]
#![feature(btree_range)]
#![feature(collections)]
#![feature(const_fn)]
#![feature(fn_traits)]
#![feature(enumset)]
-#![feature(linked_list_contains)]
#![feature(pattern)]
#![feature(rand)]
#![feature(step_by)]
#![feature(test)]
#![feature(unboxed_closures)]
#![feature(unicode)]
-#![feature(vec_deque_contains)]
#![feature(vec_into_iter_as_slice)]
extern crate collections;
/// ```
#[inline]
#[unstable(feature = "as_unsafe_cell", issue = "27708")]
+ #[rustc_deprecated(since = "1.12.0", reason = "renamed to as_ptr")]
pub fn as_unsafe_cell(&self) -> &UnsafeCell<T> {
&self.value
}
+ /// Returns a raw pointer to the underlying data in this cell.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::cell::Cell;
+ ///
+ /// let c = Cell::new(5);
+ ///
+ /// let ptr = c.as_ptr();
+ /// ```
+ #[inline]
+ #[stable(feature = "cell_as_ptr", since = "1.12.0")]
+ pub fn as_ptr(&self) -> *mut T {
+ self.value.get()
+ }
+
/// Returns a mutable reference to the underlying data.
///
/// This call borrows `Cell` mutably (at compile-time) which guarantees
/// ```
#[inline]
#[unstable(feature = "as_unsafe_cell", issue = "27708")]
+ #[rustc_deprecated(since = "1.12.0", reason = "renamed to as_ptr")]
pub unsafe fn as_unsafe_cell(&self) -> &UnsafeCell<T> {
&self.value
}
+ /// Returns a raw pointer to the underlying data in this cell.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::cell::RefCell;
+ ///
+ /// let c = RefCell::new(5);
+ ///
+ /// let ptr = c.as_ptr();
+ /// ```
+ #[inline]
+ #[stable(feature = "cell_as_ptr", since = "1.12.0")]
+ pub fn as_ptr(&self) -> *mut T {
+ self.value.get()
+ }
+
/// Returns a mutable reference to the underlying data.
///
/// This call borrows `RefCell` mutably (at compile-time) so there is no
/// implement the trait can be generated by the `sum` method. Like
/// `FromIterator` this trait should rarely be called directly and instead
/// interacted with through `Iterator::sum`.
-#[unstable(feature = "iter_arith_traits", issue = "34529")]
+#[stable(feature = "iter_arith_traits", since = "1.12.0")]
pub trait Sum<A = Self>: Sized {
/// Method which takes an iterator and generates `Self` from the elements by
/// "summing up" the items.
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
fn sum<I: Iterator<Item=A>>(iter: I) -> Self;
}
/// which implement the trait can be generated by the `product` method. Like
/// `FromIterator` this trait should rarely be called directly and instead
/// interacted with through `Iterator::product`.
-#[unstable(feature = "iter_arith_traits", issue = "34529")]
+#[stable(feature = "iter_arith_traits", since = "1.12.0")]
pub trait Product<A = Self>: Sized {
/// Method which takes an iterator and generates `Self` from the elements by
/// multiplying the items.
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
fn product<I: Iterator<Item=A>>(iter: I) -> Self;
}
macro_rules! integer_sum_product {
($($a:ident)*) => ($(
- #[unstable(feature = "iter_arith_traits", issue = "34529")]
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
impl Sum for $a {
fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {
iter.fold(0, |a, b| {
}
}
- #[unstable(feature = "iter_arith_traits", issue = "34529")]
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
impl Product for $a {
fn product<I: Iterator<Item=$a>>(iter: I) -> $a {
iter.fold(1, |a, b| {
}
}
- #[unstable(feature = "iter_arith_traits", issue = "34529")]
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
impl<'a> Sum<&'a $a> for $a {
fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
iter.fold(0, |a, b| {
}
}
- #[unstable(feature = "iter_arith_traits", issue = "34529")]
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
impl<'a> Product<&'a $a> for $a {
fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
iter.fold(1, |a, b| {
macro_rules! float_sum_product {
($($a:ident)*) => ($(
- #[unstable(feature = "iter_arith_traits", issue = "34529")]
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
impl Sum for $a {
fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {
iter.fold(0.0, |a, b| a + b)
}
}
- #[unstable(feature = "iter_arith_traits", issue = "34529")]
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
impl Product for $a {
fn product<I: Iterator<Item=$a>>(iter: I) -> $a {
iter.fold(1.0, |a, b| a * b)
}
}
- #[unstable(feature = "iter_arith_traits", issue = "34529")]
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
impl<'a> Sum<&'a $a> for $a {
fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
iter.fold(0.0, |a, b| a + *b)
}
}
- #[unstable(feature = "iter_arith_traits", issue = "34529")]
+ #[stable(feature = "iter_arith_traits", since = "1.12.0")]
impl<'a> Product<&'a $a> for $a {
fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
iter.fold(1.0, |a, b| a * *b)
}
#[test]
-fn as_unsafe_cell() {
+fn as_ptr() {
let c1: Cell<usize> = Cell::new(0);
c1.set(1);
- assert_eq!(1, unsafe { *c1.as_unsafe_cell().get() });
+ assert_eq!(1, unsafe { *c1.as_ptr() });
let c2: Cell<usize> = Cell::new(0);
- unsafe { *c2.as_unsafe_cell().get() = 1; }
+ unsafe { *c2.as_ptr() = 1; }
assert_eq!(1, c2.get());
let r1: RefCell<usize> = RefCell::new(0);
*r1.borrow_mut() = 1;
- assert_eq!(1, unsafe { *r1.as_unsafe_cell().get() });
+ assert_eq!(1, unsafe { *r1.as_ptr() });
let r2: RefCell<usize> = RefCell::new(0);
- unsafe { *r2.as_unsafe_cell().get() = 1; }
+ unsafe { *r2.as_ptr() = 1; }
assert_eq!(1, *r2.borrow());
}
#![deny(warnings)]
-#![feature(as_unsafe_cell)]
#![feature(borrow_state)]
#![feature(box_syntax)]
#![feature(cell_extras)]
self.elem.read().0
}
+ /// Deprecated, renamed to `remove_entry`
+ #[unstable(feature = "map_entry_recover_keys", issue = "34285")]
+ #[rustc_deprecated(since = "1.12.0", reason = "renamed to `remove_entry`")]
+ pub fn remove_pair(self) -> (K, V) {
+ self.remove_entry()
+ }
+
/// Take the ownership of the key and value from the map.
///
/// # Examples
///
/// ```
- /// #![feature(map_entry_recover_keys)]
- ///
/// use std::collections::HashMap;
/// use std::collections::hash_map::Entry;
///
///
/// if let Entry::Occupied(o) = map.entry("poneyland") {
/// // We delete the entry from the map.
- /// o.remove_pair();
+ /// o.remove_entry();
/// }
///
/// assert_eq!(map.contains_key("poneyland"), false);
/// ```
- #[unstable(feature = "map_entry_recover_keys", issue = "34285")]
- pub fn remove_pair(self) -> (K, V) {
+ #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")]
+ pub fn remove_entry(self) -> (K, V) {
pop_internal(self.elem)
}
/// # Examples
///
/// ```
- /// #![feature(map_entry_recover_keys)]
- ///
/// use std::collections::HashMap;
/// use std::collections::hash_map::Entry;
///
/// v.into_key();
/// }
/// ```
- #[unstable(feature = "map_entry_recover_keys", issue = "34285")]
+ #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")]
pub fn into_key(self) -> K {
self.key
}
/// Returns true for the special 'unspecified' address ([IPv4], [IPv6]).
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_unspecified
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_unspecified
- #[unstable(feature="ip", issue="27709",
- reason="recently added and depends on unstable Ipv4Addr.is_unspecified()")]
+ #[stable(feature = "ip_shared", since = "1.12.0")]
pub fn is_unspecified(&self) -> bool {
match *self {
IpAddr::V4(ref a) => a.is_unspecified(),
/// Returns true if this is a loopback address ([IPv4], [IPv6]).
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_loopback
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_loopback
- #[unstable(feature="ip", reason="recently added", issue="27709")]
+ #[stable(feature = "ip_shared", since = "1.12.0")]
pub fn is_loopback(&self) -> bool {
match *self {
IpAddr::V4(ref a) => a.is_loopback(),
/// Returns true if the address appears to be globally routable ([IPv4], [IPv6]).
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_global
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_global
- #[unstable(feature="ip", issue="27709",
- reason="recently added and depends on unstable Ip{v4,v6}Addr.is_global()")]
pub fn is_global(&self) -> bool {
match *self {
IpAddr::V4(ref a) => a.is_global(),
/// Returns true if this is a multicast address ([IPv4], [IPv6]).
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_multicast
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_multicast
- #[unstable(feature="ip", reason="recently added", issue="27709")]
+ #[stable(feature = "ip_shared", since = "1.12.0")]
pub fn is_multicast(&self) -> bool {
match *self {
IpAddr::V4(ref a) => a.is_multicast(),
/// Returns true if this address is in a range designated for documentation ([IPv4], [IPv6]).
/// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_documentation
/// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_documentation
- #[unstable(feature="ip", issue="27709",
- reason="recently added and depends on unstable Ipv6Addr.is_documentation()")]
pub fn is_documentation(&self) -> bool {
match *self {
IpAddr::V4(ref a) => a.is_documentation(),
/// This property is defined in _UNIX Network Programming, Second Edition_,
/// W. Richard Stevens, p. 891; see also [ip7]
/// [ip7][http://man7.org/linux/man-pages/man7/ip.7.html]
+ #[stable(feature = "ip_shared", since = "1.12.0")]
pub fn is_unspecified(&self) -> bool {
self.inner.s_addr == 0
}
}
/// Returns the sixteen eight-bit integers the IPv6 address consists of.
- #[unstable(feature = "ipv6_to_octets", reason = "needs some testing",
- issue = "32313")]
+ #[stable(feature = "ipv6_to_octets", since = "1.12.0")]
pub fn octets(&self) -> [u8; 16] {
self.inner.s6_addr
}
/// This enumeration is the list of possible errors that `recv_timeout` could
/// not return data when called.
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
-#[unstable(feature = "mpsc_recv_timeout", issue = "34029")]
+#[stable(feature = "mpsc_recv_timeout", since = "1.12.0")]
pub enum RecvTimeoutError {
/// This channel is currently empty, but the sender(s) have not yet
/// disconnected, so data may yet become available.
+ #[stable(feature = "mpsc_recv_timeout", since = "1.12.0")]
Timeout,
/// This channel's sending half has become disconnected, and there will
/// never be any more data received on this channel
+ #[stable(feature = "mpsc_recv_timeout", since = "1.12.0")]
Disconnected,
}
/// # Examples
///
/// ```no_run
- /// #![feature(mpsc_recv_timeout)]
- ///
/// use std::sync::mpsc::{self, RecvTimeoutError};
/// use std::time::Duration;
///
/// let timeout = Duration::from_millis(100);
/// assert_eq!(Err(RecvTimeoutError::Timeout), recv.recv_timeout(timeout));
/// ```
- #[unstable(feature = "mpsc_recv_timeout", issue = "34029")]
+ #[stable(feature = "mpsc_recv_timeout", since = "1.12.0")]
pub fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError> {
// Do an optimistic try_recv to avoid the performance impact of
// Instant::now() in the full-channel case.
pub trait ExitStatusExt {
/// Creates a new `ExitStatus` from the raw underlying `i32` return value of
/// a process.
- #[unstable(feature = "exit_status_from", issue = "32713")]
+ #[stable(feature = "exit_status_from", since = "1.12.0")]
fn from_raw(raw: i32) -> Self;
/// If the process was terminated by a signal, returns that signal.
}
/// Windows-specific extensions to `std::process::ExitStatus`
-#[unstable(feature = "exit_status_from", issue = "32713")]
+#[stable(feature = "exit_status_from", since = "1.12.0")]
pub trait ExitStatusExt {
/// Creates a new `ExitStatus` from the raw underlying `u32` return value of
/// a process.
+ #[stable(feature = "exit_status_from", since = "1.12.0")]
fn from_raw(raw: u32) -> Self;
}
#![feature(staged_api)]
#![feature(question_mark)]
#![feature(panic_unwind)]
-#![feature(mpsc_recv_timeout)]
extern crate getopts;
extern crate term;
projects / rust.git / commitdiff