weak: atomic::AtomicUsize::new(1),
data,
};
- Arc { ptr: Box::into_non_null_raw(x), phantom: PhantomData }
+ Arc { ptr: Box::into_raw_non_null(x), phantom: PhantomData }
}
/// Returns the contained value, if the `Arc` has exactly one strong reference.
pub fn new() -> Weak<T> {
unsafe {
Weak {
- ptr: Box::into_non_null_raw(box ArcInner {
+ ptr: Box::into_raw_non_null(box ArcInner {
strong: atomic::AtomicUsize::new(0),
weak: atomic::AtomicUsize::new(1),
data: uninitialized(),
#[stable(feature = "box_raw", since = "1.4.0")]
#[inline]
pub fn into_raw(b: Box<T>) -> *mut T {
- Box::into_non_null_raw(b).as_ptr()
+ Box::into_raw_non_null(b).as_ptr()
}
/// Consumes the `Box`, returning the wrapped pointer as `NonNull<T>`.
/// function.
///
/// Note: this is an associated function, which means that you have
- /// to call it as `Box::into_non_null_raw(b)`
- /// instead of `b.into_non_null_raw()`. This
+ /// to call it as `Box::into_raw_non_null(b)`
+ /// instead of `b.into_raw_non_null()`. This
/// is so that there is no conflict with a method on the inner type.
///
/// [`Box::from_raw`]: struct.Box.html#method.from_raw
/// ```
/// fn main() {
/// let x = Box::new(5);
- /// let ptr = Box::into_non_null_raw(x);
+ /// let ptr = Box::into_raw_non_null(x);
/// }
/// ```
#[stable(feature = "nonnull", since = "1.24.0")]
#[inline]
- pub fn into_non_null_raw(b: Box<T>) -> NonNull<T> {
+ pub fn into_raw_non_null(b: Box<T>) -> NonNull<T> {
Box::into_unique(b).into()
}
- #[unstable(feature = "ptr_internals", issue = "0", reason = "use into_non_null_raw instead")]
+ #[unstable(feature = "ptr_internals", issue = "0", reason = "use into_raw_non_null instead")]
#[inline]
pub fn into_unique(b: Box<T>) -> Unique<T> {
let unique = b.0;
unsafe {
node.next = self.head;
node.prev = None;
- let node = Some(Box::into_non_null_raw(node));
+ let node = Some(Box::into_raw_non_null(node));
match self.head {
None => self.tail = node,
unsafe {
node.next = None;
node.prev = self.tail;
- let node = Some(Box::into_non_null_raw(node));
+ let node = Some(Box::into_raw_non_null(node));
match self.tail {
None => self.head = node,
Some(prev) => prev,
};
- let node = Some(Box::into_non_null_raw(box Node {
+ let node = Some(Box::into_raw_non_null(box Node {
next: Some(head),
prev: Some(prev),
element,
// pointers, which ensures that the weak destructor never frees
// the allocation while the strong destructor is running, even
// if the weak pointer is stored inside the strong one.
- ptr: Box::into_non_null_raw(box RcBox {
+ ptr: Box::into_raw_non_null(box RcBox {
strong: Cell::new(1),
weak: Cell::new(1),
value,
pub fn new() -> Weak<T> {
unsafe {
Weak {
- ptr: Box::into_non_null_raw(box RcBox {
+ ptr: Box::into_raw_non_null(box RcBox {
strong: Cell::new(0),
weak: Cell::new(1),
value: uninitialized(),