From 6e8e4f847c2ea02fec021ea15dfb2de6beac797a Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Mon, 25 May 2015 20:21:29 +0300 Subject: Remove #[cfg(stage0)] items. --- src/liballoc/arc_stage0.rs | 686 --------------------------------------------- src/liballoc/boxed.rs | 9 +- src/liballoc/lib.rs | 7 - src/liballoc/rc.rs | 419 +-------------------------- 4 files changed, 6 insertions(+), 1115 deletions(-) delete mode 100644 src/liballoc/arc_stage0.rs (limited to 'src/liballoc') diff --git a/src/liballoc/arc_stage0.rs b/src/liballoc/arc_stage0.rs deleted file mode 100644 index 290b0566fd1..00000000000 --- a/src/liballoc/arc_stage0.rs +++ /dev/null @@ -1,686 +0,0 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -#![stable(feature = "rust1", since = "1.0.0")] - -//! Threadsafe reference-counted boxes (the `Arc` type). -//! -//! The `Arc` type provides shared ownership of an immutable value. -//! Destruction is deterministic, and will occur as soon as the last owner is -//! gone. It is marked as `Send` because it uses atomic reference counting. -//! -//! If you do not need thread-safety, and just need shared ownership, consider -//! the [`Rc` type](../rc/struct.Rc.html). It is the same as `Arc`, but -//! does not use atomics, making it both thread-unsafe as well as significantly -//! faster when updating the reference count. -//! -//! The `downgrade` method can be used to create a non-owning `Weak` pointer -//! to the box. A `Weak` pointer can be upgraded to an `Arc` pointer, but -//! will return `None` if the value has already been dropped. -//! -//! For example, a tree with parent pointers can be represented by putting the -//! nodes behind strong `Arc` pointers, and then storing the parent pointers -//! as `Weak` pointers. -//! -//! # Examples -//! -//! Sharing some immutable data between threads: -//! -//! ```no_run -//! use std::sync::Arc; -//! use std::thread; -//! -//! let five = Arc::new(5); -//! -//! for _ in 0..10 { -//! let five = five.clone(); -//! -//! thread::spawn(move || { -//! println!("{:?}", five); -//! }); -//! } -//! ``` -//! -//! Sharing mutable data safely between threads with a `Mutex`: -//! -//! ```no_run -//! use std::sync::{Arc, Mutex}; -//! use std::thread; -//! -//! let five = Arc::new(Mutex::new(5)); -//! -//! for _ in 0..10 { -//! let five = five.clone(); -//! -//! thread::spawn(move || { -//! let mut number = five.lock().unwrap(); -//! -//! *number += 1; -//! -//! println!("{}", *number); // prints 6 -//! }); -//! } -//! ``` - -use boxed::Box; - -use core::prelude::*; - -use core::atomic; -use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst}; -use core::fmt; -use core::cmp::Ordering; -use core::mem::{min_align_of, size_of}; -use core::mem; -use core::nonzero::NonZero; -use core::ops::Deref; -use core::ptr; -use core::hash::{Hash, Hasher}; -use heap::deallocate; - -/// An atomically reference counted wrapper for shared state. -/// -/// # Examples -/// -/// In this example, a large vector of floats is shared between several threads. -/// With simple pipes, without `Arc`, a copy would have to be made for each -/// thread. -/// -/// When you clone an `Arc`, it will create another pointer to the data and -/// increase the reference counter. -/// -/// ``` -/// # #![feature(alloc, core)] -/// use std::sync::Arc; -/// use std::thread; -/// -/// fn main() { -/// let numbers: Vec<_> = (0..100u32).collect(); -/// let shared_numbers = Arc::new(numbers); -/// -/// for _ in 0..10 { -/// let child_numbers = shared_numbers.clone(); -/// -/// thread::spawn(move || { -/// let local_numbers = &child_numbers[..]; -/// -/// // Work with the local numbers -/// }); -/// } -/// } -/// ``` -#[unsafe_no_drop_flag] -#[stable(feature = "rust1", since = "1.0.0")] -pub struct Arc { - // FIXME #12808: strange name to try to avoid interfering with - // field accesses of the contained type via Deref - _ptr: NonZero<*mut ArcInner>, -} - -unsafe impl Send for Arc { } -unsafe impl Sync for Arc { } - - -/// A weak pointer to an `Arc`. -/// -/// 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(feature = "alloc", - reason = "Weak pointers may not belong in this module.")] -pub struct Weak { - // FIXME #12808: strange name to try to avoid interfering with - // field accesses of the contained type via Deref - _ptr: NonZero<*mut ArcInner>, -} - -unsafe impl Send for Weak { } -unsafe impl Sync for Weak { } - -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for Weak { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "(Weak)") - } -} - -struct ArcInner { - strong: atomic::AtomicUsize, - weak: atomic::AtomicUsize, - data: T, -} - -unsafe impl Send for ArcInner {} -unsafe impl Sync for ArcInner {} - -impl Arc { - /// Constructs a new `Arc`. - /// - /// # Examples - /// - /// ``` - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// ``` - #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn new(data: T) -> Arc { - // 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 - let x: Box<_> = box ArcInner { - strong: atomic::AtomicUsize::new(1), - weak: atomic::AtomicUsize::new(1), - data: data, - }; - Arc { _ptr: unsafe { NonZero::new(mem::transmute(x)) } } - } - - /// Downgrades the `Arc` to a `Weak` reference. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// let weak_five = five.downgrade(); - /// ``` - #[unstable(feature = "alloc", - reason = "Weak pointers may not belong in this module.")] - pub fn downgrade(&self) -> Weak { - // See the clone() impl for why this is relaxed - self.inner().weak.fetch_add(1, Relaxed); - Weak { _ptr: self._ptr } - } -} - -impl Arc { - #[inline] - fn inner(&self) -> &ArcInner { - // This unsafety is ok because while this arc is alive we're guaranteed - // that the inner pointer is valid. Furthermore, we know that the - // `ArcInner` structure itself is `Sync` because the inner data is - // `Sync` as well, so we're ok loaning out an immutable pointer to these - // contents. - unsafe { &**self._ptr } - } - - // Non-inlined part of `drop`. - #[inline(never)] - unsafe fn drop_slow(&mut self) { - let ptr = *self._ptr; - - // Destroy the data at this time, even though we may not free the box - // allocation itself (there may still be weak pointers lying around). - drop(ptr::read(&self.inner().data)); - - if self.inner().weak.fetch_sub(1, Release) == 1 { - atomic::fence(Acquire); - deallocate(ptr as *mut u8, size_of::>(), min_align_of::>()) - } - } -} - -/// Get the number of weak references to this value. -#[inline] -#[unstable(feature = "alloc")] -pub fn weak_count(this: &Arc) -> usize { this.inner().weak.load(SeqCst) - 1 } - -/// Get the number of strong references to this value. -#[inline] -#[unstable(feature = "alloc")] -pub fn strong_count(this: &Arc) -> usize { this.inner().strong.load(SeqCst) } - - -/// Returns a mutable reference to the contained value if the `Arc` is unique. -/// -/// Returns `None` if the `Arc` is not unique. -/// -/// # Examples -/// -/// ``` -/// # #![feature(alloc)] -/// extern crate alloc; -/// # fn main() { -/// use alloc::arc::{Arc, get_mut}; -/// -/// let mut x = Arc::new(3); -/// *get_mut(&mut x).unwrap() = 4; -/// assert_eq!(*x, 4); -/// -/// let _y = x.clone(); -/// assert!(get_mut(&mut x).is_none()); -/// # } -/// ``` -#[inline] -#[unstable(feature = "alloc")] -pub fn get_mut(this: &mut Arc) -> Option<&mut T> { - if strong_count(this) == 1 && weak_count(this) == 0 { - // This unsafety is ok because we're guaranteed that the pointer - // returned is the *only* pointer that will ever be returned to T. Our - // reference count is guaranteed to be 1 at this point, and we required - // the Arc itself to be `mut`, so we're returning the only possible - // reference to the inner data. - let inner = unsafe { &mut **this._ptr }; - Some(&mut inner.data) - } else { - None - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Arc { - /// Makes a clone of the `Arc`. - /// - /// This increases the strong reference count. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// five.clone(); - /// ``` - #[inline] - fn clone(&self) -> Arc { - // Using a relaxed ordering is alright here, as knowledge of the - // original reference prevents other threads from erroneously deleting - // the object. - // - // As explained in the [Boost documentation][1], Increasing the - // reference counter can always be done with memory_order_relaxed: New - // references to an object can only be formed from an existing - // reference, and passing an existing reference from one thread to - // another must already provide any required synchronization. - // - // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) - self.inner().strong.fetch_add(1, Relaxed); - Arc { _ptr: self._ptr } - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Deref for Arc { - type Target = T; - - #[inline] - fn deref(&self) -> &T { - &self.inner().data - } -} - -impl Arc { - /// Make a mutable reference from the given `Arc`. - /// - /// This is also referred to as a copy-on-write operation because the inner - /// data is cloned if the reference count is greater than one. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::sync::Arc; - /// - /// let mut five = Arc::new(5); - /// - /// let mut_five = five.make_unique(); - /// ``` - #[inline] - #[unstable(feature = "alloc")] - 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. - if self.inner().strong.load(SeqCst) != 1 || - self.inner().weak.load(SeqCst) != 1 { - *self = Arc::new((**self).clone()) - } - // As with `get_mut()`, the unsafety is ok because our reference was - // either unique to begin with, or became one upon cloning the contents. - let inner = unsafe { &mut **self._ptr }; - &mut inner.data - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Drop for Arc { - /// Drops the `Arc`. - /// - /// This will decrement the strong reference count. If the strong reference - /// count becomes zero and the only other references are `Weak` ones, - /// `drop`s the inner value. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::sync::Arc; - /// - /// { - /// let five = Arc::new(5); - /// - /// // stuff - /// - /// drop(five); // explicit drop - /// } - /// { - /// let five = Arc::new(5); - /// - /// // stuff - /// - /// } // implicit drop - /// ``` - #[inline] - fn drop(&mut self) { - // This structure has #[unsafe_no_drop_flag], so this drop glue may run - // more than once (but it is guaranteed to be zeroed after the first if - // it's run more than once) - let ptr = *self._ptr; - // if ptr.is_null() { return } - if ptr.is_null() || ptr as usize == mem::POST_DROP_USIZE { return } - - // Because `fetch_sub` is already atomic, we do not need to synchronize - // with other threads unless we are going to delete the object. This - // same logic applies to the below `fetch_sub` to the `weak` count. - if self.inner().strong.fetch_sub(1, Release) != 1 { return } - - // This fence is needed to prevent reordering of use of the data and - // deletion of the data. Because it is marked `Release`, the decreasing - // of the reference count synchronizes with this `Acquire` fence. This - // means that use of the data happens before decreasing the reference - // count, which happens before this fence, which happens before the - // deletion of the data. - // - // As explained in the [Boost documentation][1], - // - // > It is important to enforce any possible access to the object in one - // > thread (through an existing reference) to *happen before* deleting - // > the object in a different thread. This is achieved by a "release" - // > operation after dropping a reference (any access to the object - // > through this reference must obviously happened before), and an - // > "acquire" operation before deleting the object. - // - // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) - atomic::fence(Acquire); - - unsafe { - self.drop_slow() - } - } -} - -#[unstable(feature = "alloc", - reason = "Weak pointers may not belong in this module.")] -impl Weak { - /// Upgrades a weak reference to a strong reference. - /// - /// Upgrades the `Weak` reference to an `Arc`, if possible. - /// - /// Returns `None` if there were no strong references and the data was - /// destroyed. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// let weak_five = five.downgrade(); - /// - /// let strong_five: Option> = weak_five.upgrade(); - /// ``` - pub fn upgrade(&self) -> Option> { - // We use a CAS loop to increment the strong count instead of a - // fetch_add because once the count hits 0 it must never be above 0. - let inner = self.inner(); - loop { - let n = inner.strong.load(SeqCst); - if n == 0 { return None } - let old = inner.strong.compare_and_swap(n, n + 1, SeqCst); - if old == n { return Some(Arc { _ptr: self._ptr }) } - } - } - - #[inline] - fn inner(&self) -> &ArcInner { - // See comments above for why this is "safe" - unsafe { &**self._ptr } - } -} - -#[unstable(feature = "alloc", - reason = "Weak pointers may not belong in this module.")] -impl Clone for Weak { - /// Makes a clone of the `Weak`. - /// - /// This increases the weak reference count. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::sync::Arc; - /// - /// let weak_five = Arc::new(5).downgrade(); - /// - /// weak_five.clone(); - /// ``` - #[inline] - fn clone(&self) -> Weak { - // See comments in Arc::clone() for why this is relaxed - self.inner().weak.fetch_add(1, Relaxed); - Weak { _ptr: self._ptr } - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Drop for Weak { - /// Drops the `Weak`. - /// - /// This will decrement the weak reference count. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::sync::Arc; - /// - /// { - /// let five = Arc::new(5); - /// let weak_five = five.downgrade(); - /// - /// // stuff - /// - /// drop(weak_five); // explicit drop - /// } - /// { - /// let five = Arc::new(5); - /// let weak_five = five.downgrade(); - /// - /// // stuff - /// - /// } // implicit drop - /// ``` - fn drop(&mut self) { - let ptr = *self._ptr; - - // see comments above for why this check is here - if ptr.is_null() || ptr as usize == mem::POST_DROP_USIZE { return } - - // If we find out that we were the last weak pointer, then its time to - // deallocate the data entirely. See the discussion in Arc::drop() about - // the memory orderings - if self.inner().weak.fetch_sub(1, Release) == 1 { - atomic::fence(Acquire); - unsafe { deallocate(ptr as *mut u8, size_of::>(), - min_align_of::>()) } - } - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl PartialEq for Arc { - /// Equality for two `Arc`s. - /// - /// Two `Arc`s are equal if their inner value are equal. - /// - /// # Examples - /// - /// ``` - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// five == Arc::new(5); - /// ``` - fn eq(&self, other: &Arc) -> bool { *(*self) == *(*other) } - - /// Inequality for two `Arc`s. - /// - /// Two `Arc`s are unequal if their inner value are unequal. - /// - /// # Examples - /// - /// ``` - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// five != Arc::new(5); - /// ``` - fn ne(&self, other: &Arc) -> bool { *(*self) != *(*other) } -} -#[stable(feature = "rust1", since = "1.0.0")] -impl PartialOrd for Arc { - /// Partial comparison for two `Arc`s. - /// - /// The two are compared by calling `partial_cmp()` on their inner values. - /// - /// # Examples - /// - /// ``` - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// five.partial_cmp(&Arc::new(5)); - /// ``` - fn partial_cmp(&self, other: &Arc) -> Option { - (**self).partial_cmp(&**other) - } - - /// Less-than comparison for two `Arc`s. - /// - /// The two are compared by calling `<` on their inner values. - /// - /// # Examples - /// - /// ``` - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// five < Arc::new(5); - /// ``` - fn lt(&self, other: &Arc) -> bool { *(*self) < *(*other) } - - /// 'Less-than or equal to' comparison for two `Arc`s. - /// - /// The two are compared by calling `<=` on their inner values. - /// - /// # Examples - /// - /// ``` - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// five <= Arc::new(5); - /// ``` - fn le(&self, other: &Arc) -> bool { *(*self) <= *(*other) } - - /// Greater-than comparison for two `Arc`s. - /// - /// The two are compared by calling `>` on their inner values. - /// - /// # Examples - /// - /// ``` - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// five > Arc::new(5); - /// ``` - fn gt(&self, other: &Arc) -> bool { *(*self) > *(*other) } - - /// 'Greater-than or equal to' comparison for two `Arc`s. - /// - /// The two are compared by calling `>=` on their inner values. - /// - /// # Examples - /// - /// ``` - /// use std::sync::Arc; - /// - /// let five = Arc::new(5); - /// - /// five >= Arc::new(5); - /// ``` - fn ge(&self, other: &Arc) -> bool { *(*self) >= *(*other) } -} -#[stable(feature = "rust1", since = "1.0.0")] -impl Ord for Arc { - fn cmp(&self, other: &Arc) -> Ordering { (**self).cmp(&**other) } -} -#[stable(feature = "rust1", since = "1.0.0")] -impl Eq for Arc {} - -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Display for Arc { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&**self, f) - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for Arc { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&**self, f) - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Pointer for Arc { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Pointer::fmt(&*self._ptr, f) - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Default for Arc { - #[stable(feature = "rust1", since = "1.0.0")] - fn default() -> Arc { Arc::new(Default::default()) } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Hash for Arc { - fn hash(&self, state: &mut H) { - (**self).hash(state) - } -} diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 6633e48a814..12eadcc145d 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -57,16 +57,12 @@ use core::any::Any; use core::cmp::Ordering; use core::fmt; use core::hash::{self, Hash}; +use core::marker::Unsize; use core::mem; -use core::ops::{Deref, DerefMut}; +use core::ops::{CoerceUnsized, Deref, DerefMut}; use core::ptr::{Unique}; use core::raw::{TraitObject}; -#[cfg(not(stage0))] -use core::marker::Unsize; -#[cfg(not(stage0))] -use core::ops::CoerceUnsized; - /// A value that represents the heap. This is the default place that the `box` /// keyword allocates into when no place is supplied. /// @@ -392,5 +388,4 @@ impl<'a,A,R> FnOnce for Box+Send+'a> { } } -#[cfg(not(stage0))] impl, U: ?Sized> CoerceUnsized> for Box {} diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index 45dcea909f4..ac5a5d60cbd 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -112,14 +112,7 @@ pub mod boxed; mod boxed { pub use std::boxed::{Box, HEAP}; } #[cfg(test)] mod boxed_test; -#[cfg(not(stage0))] pub mod arc; -#[cfg(stage0)] -mod arc_stage0; -#[cfg(stage0)] -pub mod arc { - pub use arc_stage0::*; -} pub mod rc; /// Common out-of-memory routine diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 1f660449593..44f4a6a6290 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -159,36 +159,19 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering}; use core::default::Default; use core::fmt; use core::hash::{Hasher, Hash}; -use core::marker::{self, Sized}; -use core::mem::{self, min_align_of, size_of, forget}; +use core::intrinsics::{assume, drop_in_place}; +use core::marker::{self, Sized, Unsize}; +use core::mem::{self, min_align_of, size_of, min_align_of_val, size_of_val, forget}; use core::nonzero::NonZero; -use core::ops::{Deref, Drop}; +use core::ops::{CoerceUnsized, Deref, Drop}; use core::option::Option; use core::option::Option::{Some, None}; use core::ptr; use core::result::Result; use core::result::Result::{Ok, Err}; -use core::intrinsics::assume; - -#[cfg(not(stage0))] -use core::intrinsics::drop_in_place; -#[cfg(not(stage0))] -use core::marker::Unsize; -#[cfg(not(stage0))] -use core::mem::{min_align_of_val, size_of_val}; -#[cfg(not(stage0))] -use core::ops::CoerceUnsized; use heap::deallocate; -#[cfg(stage0)] -struct RcBox { - strong: Cell, - weak: Cell, - value: T, -} - -#[cfg(not(stage0))] struct RcBox { strong: Cell, weak: Cell, @@ -199,15 +182,6 @@ struct RcBox { /// A reference-counted pointer type over an immutable value. /// /// See the [module level documentation](./index.html) for more details. -#[cfg(stage0)] -#[unsafe_no_drop_flag] -#[stable(feature = "rust1", since = "1.0.0")] -pub struct Rc { - // FIXME #12808: strange names to try to avoid interfering with field - // accesses of the contained type via Deref - _ptr: NonZero<*mut RcBox>, -} -#[cfg(not(stage0))] #[unsafe_no_drop_flag] #[stable(feature = "rust1", since = "1.0.0")] pub struct Rc { @@ -216,19 +190,9 @@ pub struct Rc { _ptr: NonZero<*mut RcBox>, } -#[cfg(stage0)] -impl !marker::Send for Rc {} - -#[cfg(not(stage0))] impl !marker::Send for Rc {} - -#[cfg(stage0)] -impl !marker::Sync for Rc {} - -#[cfg(not(stage0))] impl !marker::Sync for Rc {} -#[cfg(not(stage0))] impl, U: ?Sized> CoerceUnsized> for Rc {} impl Rc { @@ -259,7 +223,6 @@ impl Rc { } } -#[cfg(not(stage0))] impl Rc { /// Downgrades the `Rc` to a `Weak` reference. /// @@ -281,44 +244,12 @@ impl Rc { } } -#[cfg(stage0)] -impl Rc { - /// Downgrades the `Rc` to a `Weak` reference. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::rc::Rc; - /// - /// let five = Rc::new(5); - /// - /// let weak_five = five.downgrade(); - /// ``` - #[unstable(feature = "alloc", - reason = "Weak pointers may not belong in this module")] - pub fn downgrade(&self) -> Weak { - self.inc_weak(); - Weak { _ptr: self._ptr } - } -} - /// Get the number of weak references to this value. -#[cfg(stage0)] -#[inline] -#[unstable(feature = "alloc")] -pub fn weak_count(this: &Rc) -> usize { this.weak() - 1 } -#[cfg(not(stage0))] #[inline] #[unstable(feature = "alloc")] pub fn weak_count(this: &Rc) -> usize { this.weak() - 1 } /// Get the number of strong references to this value. -#[cfg(stage0)] -#[inline] -#[unstable(feature = "alloc")] -pub fn strong_count(this: &Rc) -> usize { this.strong() } -#[cfg(not(stage0))] #[inline] #[unstable(feature = "alloc")] pub fn strong_count(this: &Rc) -> usize { this.strong() } @@ -438,17 +369,6 @@ impl Rc { } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl Deref for Rc { - type Target = T; - - #[inline(always)] - fn deref(&self) -> &T { - &self.inner().value - } -} -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl Deref for Rc { type Target = T; @@ -459,58 +379,6 @@ impl Deref for Rc { } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl Drop for Rc { - /// Drops the `Rc`. - /// - /// This will decrement the strong reference count. If the strong reference - /// count becomes zero and the only other references are `Weak` ones, - /// `drop`s the inner value. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::rc::Rc; - /// - /// { - /// let five = Rc::new(5); - /// - /// // stuff - /// - /// drop(five); // explicit drop - /// } - /// { - /// let five = Rc::new(5); - /// - /// // stuff - /// - /// } // implicit drop - /// ``` - fn drop(&mut self) { - unsafe { - let ptr = *self._ptr; - if !ptr.is_null() && ptr as usize != mem::POST_DROP_USIZE { - self.dec_strong(); - if self.strong() == 0 { - ptr::read(&**self); // destroy the contained object - - // remove the implicit "strong weak" pointer now that we've - // destroyed the contents. - self.dec_weak(); - - if self.weak() == 0 { - deallocate(ptr as *mut u8, size_of::>(), - min_align_of::>()) - } - } - } - } - } -} - -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl Drop for Rc { /// Drops the `Rc`. @@ -564,32 +432,6 @@ impl Drop for Rc { } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Rc { - - /// Makes a clone of the `Rc`. - /// - /// When you clone an `Rc`, it will create another pointer to the data and - /// increase the strong reference counter. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::rc::Rc; - /// - /// let five = Rc::new(5); - /// - /// five.clone(); - /// ``` - #[inline] - fn clone(&self) -> Rc { - self.inc_strong(); - Rc { _ptr: self._ptr } - } -} -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl Clone for Rc { @@ -634,17 +476,6 @@ impl Default for Rc { } #[stable(feature = "rust1", since = "1.0.0")] -#[cfg(stage0)] -impl PartialEq for Rc { - #[inline(always)] - fn eq(&self, other: &Rc) -> bool { **self == **other } - - #[inline(always)] - fn ne(&self, other: &Rc) -> bool { **self != **other } -} - -#[stable(feature = "rust1", since = "1.0.0")] -#[cfg(not(stage0))] impl PartialEq for Rc { /// Equality for two `Rc`s. /// @@ -680,34 +511,9 @@ impl PartialEq for Rc { } #[stable(feature = "rust1", since = "1.0.0")] -#[cfg(stage0)] -impl Eq for Rc {} -#[stable(feature = "rust1", since = "1.0.0")] -#[cfg(not(stage0))] impl Eq for Rc {} #[stable(feature = "rust1", since = "1.0.0")] -#[cfg(stage0)] -impl PartialOrd for Rc { - #[inline(always)] - fn partial_cmp(&self, other: &Rc) -> Option { - (**self).partial_cmp(&**other) - } - - #[inline(always)] - fn lt(&self, other: &Rc) -> bool { **self < **other } - - #[inline(always)] - fn le(&self, other: &Rc) -> bool { **self <= **other } - - #[inline(always)] - fn gt(&self, other: &Rc) -> bool { **self > **other } - - #[inline(always)] - fn ge(&self, other: &Rc) -> bool { **self >= **other } -} -#[stable(feature = "rust1", since = "1.0.0")] -#[cfg(not(stage0))] impl PartialOrd for Rc { /// Partial comparison for two `Rc`s. /// @@ -793,13 +599,6 @@ impl PartialOrd for Rc { } #[stable(feature = "rust1", since = "1.0.0")] -#[cfg(stage0)] -impl Ord for Rc { - #[inline] - fn cmp(&self, other: &Rc) -> Ordering { (**self).cmp(&**other) } -} -#[stable(feature = "rust1", since = "1.0.0")] -#[cfg(not(stage0))] impl Ord for Rc { /// Comparison for two `Rc`s. /// @@ -818,14 +617,6 @@ impl Ord for Rc { fn cmp(&self, other: &Rc) -> Ordering { (**self).cmp(&**other) } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl Hash for Rc { - fn hash(&self, state: &mut H) { - (**self).hash(state); - } -} -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl Hash for Rc { fn hash(&self, state: &mut H) { @@ -833,14 +624,6 @@ impl Hash for Rc { } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Display for Rc { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&**self, f) - } -} -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Display for Rc { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { @@ -848,14 +631,6 @@ impl fmt::Display for Rc { } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for Rc { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&**self, f) - } -} -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for Rc { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { @@ -876,16 +651,6 @@ impl fmt::Pointer for Rc { /// dropped. /// /// See the [module level documentation](./index.html) for more. -#[cfg(stage0)] -#[unsafe_no_drop_flag] -#[unstable(feature = "alloc", - reason = "Weak pointers may not belong in this module.")] -pub struct Weak { - // FIXME #12808: strange names to try to avoid interfering with - // field accesses of the contained type via Deref - _ptr: NonZero<*mut RcBox>, -} -#[cfg(not(stage0))] #[unsafe_no_drop_flag] #[unstable(feature = "alloc", reason = "Weak pointers may not belong in this module.")] @@ -895,51 +660,9 @@ pub struct Weak { _ptr: NonZero<*mut RcBox>, } -#[cfg(stage0)] -impl !marker::Send for Weak {} -#[cfg(not(stage0))] impl !marker::Send for Weak {} - -#[cfg(stage0)] -impl !marker::Sync for Weak {} -#[cfg(not(stage0))] impl !marker::Sync for Weak {} - -#[cfg(stage0)] -#[unstable(feature = "alloc", - reason = "Weak pointers may not belong in this module.")] -impl Weak { - - /// Upgrades a weak reference to a strong reference. - /// - /// Upgrades the `Weak` reference to an `Rc`, if possible. - /// - /// Returns `None` if there were no strong references and the data was - /// destroyed. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::rc::Rc; - /// - /// let five = Rc::new(5); - /// - /// let weak_five = five.downgrade(); - /// - /// let strong_five: Option> = weak_five.upgrade(); - /// ``` - pub fn upgrade(&self) -> Option> { - if self.strong() == 0 { - None - } else { - self.inc_strong(); - Some(Rc { _ptr: self._ptr }) - } - } -} -#[cfg(not(stage0))] #[unstable(feature = "alloc", reason = "Weak pointers may not belong in this module.")] impl Weak { @@ -973,52 +696,6 @@ impl Weak { } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl Drop for Weak { - /// Drops the `Weak`. - /// - /// This will decrement the weak reference count. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::rc::Rc; - /// - /// { - /// let five = Rc::new(5); - /// let weak_five = five.downgrade(); - /// - /// // stuff - /// - /// drop(weak_five); // explicit drop - /// } - /// { - /// let five = Rc::new(5); - /// let weak_five = five.downgrade(); - /// - /// // stuff - /// - /// } // implicit drop - /// ``` - fn drop(&mut self) { - unsafe { - let ptr = *self._ptr; - if !ptr.is_null() && ptr as usize != mem::POST_DROP_USIZE { - self.dec_weak(); - // the weak count starts at 1, and will only go to zero if all - // the strong pointers have disappeared. - if self.weak() == 0 { - deallocate(ptr as *mut u8, size_of::>(), - min_align_of::>()) - } - } - } - } -} - -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl Drop for Weak { /// Drops the `Weak`. @@ -1064,32 +741,6 @@ impl Drop for Weak { } } -#[cfg(stage0)] -#[unstable(feature = "alloc", - reason = "Weak pointers may not belong in this module.")] -impl Clone for Weak { - - /// Makes a clone of the `Weak`. - /// - /// This increases the weak reference count. - /// - /// # Examples - /// - /// ``` - /// # #![feature(alloc)] - /// use std::rc::Rc; - /// - /// let weak_five = Rc::new(5).downgrade(); - /// - /// weak_five.clone(); - /// ``` - #[inline] - fn clone(&self) -> Weak { - self.inc_weak(); - Weak { _ptr: self._ptr } - } -} -#[cfg(not(stage0))] #[unstable(feature = "alloc", reason = "Weak pointers may not belong in this module.")] impl Clone for Weak { @@ -1115,14 +766,6 @@ impl Clone for Weak { } } -#[cfg(stage0)] -#[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for Weak { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "(Weak)") - } -} -#[cfg(not(stage0))] #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for Weak { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { @@ -1130,30 +773,6 @@ impl fmt::Debug for Weak { } } -#[cfg(stage0)] -#[doc(hidden)] -trait RcBoxPtr { - fn inner(&self) -> &RcBox; - - #[inline] - fn strong(&self) -> usize { self.inner().strong.get() } - - #[inline] - fn inc_strong(&self) { self.inner().strong.set(self.strong() + 1); } - - #[inline] - fn dec_strong(&self) { self.inner().strong.set(self.strong() - 1); } - - #[inline] - fn weak(&self) -> usize { self.inner().weak.get() } - - #[inline] - fn inc_weak(&self) { self.inner().weak.set(self.weak() + 1); } - - #[inline] - fn dec_weak(&self) { self.inner().weak.set(self.weak() - 1); } -} -#[cfg(not(stage0))] #[doc(hidden)] trait RcBoxPtr { fn inner(&self) -> &RcBox; @@ -1177,21 +796,6 @@ trait RcBoxPtr { fn dec_weak(&self) { self.inner().weak.set(self.weak() - 1); } } -#[cfg(stage0)] -impl RcBoxPtr for Rc { - #[inline(always)] - fn inner(&self) -> &RcBox { - unsafe { - // Safe to assume this here, as if it weren't true, we'd be breaking - // the contract anyway. - // This allows the null check to be elided in the destructor if we - // manipulated the reference count in the same function. - assume(!(*(&self._ptr as *const _ as *const *const ())).is_null()); - &(**self._ptr) - } - } -} -#[cfg(not(stage0))] impl RcBoxPtr for Rc { #[inline(always)] fn inner(&self) -> &RcBox { @@ -1206,21 +810,6 @@ impl RcBoxPtr for Rc { } } -#[cfg(stage0)] -impl RcBoxPtr for Weak { - #[inline(always)] - fn inner(&self) -> &RcBox { - unsafe { - // Safe to assume this here, as if it weren't true, we'd be breaking - // the contract anyway. - // This allows the null check to be elided in the destructor if we - // manipulated the reference count in the same function. - assume(!(*(&self._ptr as *const _ as *const *const ())).is_null()); - &(**self._ptr) - } - } -} -#[cfg(not(stage0))] impl RcBoxPtr for Weak { #[inline(always)] fn inner(&self) -> &RcBox { -- cgit 1.4.1-3-g733a5