pub struct Shared<T> where T: ?Sized, { /* fields omitted */ }
A wrapper around a raw *mut T that indicates that the possessor of this wrapper has shared ownership of the referent. Useful for building abstractions like Rc<T>, Arc<T>, or doubly-linked lists, which internally use aliased raw pointers to manage the memory that they own.
This is similar to Unique, except that it doesn't make any aliasing guarantees, and doesn't derive Send and Sync. Note that unlike &T, Shared has no special mutability requirements. Shared may mutate data aliased by other Shared pointers. More precise rules require Rust to develop an actual aliasing model.
Unlike *mut T, the pointer must always be non-null, even if the pointer is never dereferenced. This is so that enums may use this forbidden value as a discriminant -- Option<Shared<T>> has the same size as Shared<T>. However the pointer may still dangle if it isn't dereferenced.
Unlike *mut T, Shared<T> is covariant over T. If this is incorrect for your use case, you should include some PhantomData in your type to provide invariance, such as PhantomData<Cell<T>> or PhantomData<&'a mut T>. Usually this won't be necessary; covariance is correct for Rc, Arc, and LinkedList because they provide a public API that follows the normal shared XOR mutable rules of Rust.
impl<T> Shared<T>
[src]
fn empty() -> Shared<T>
[src]
Creates a new Shared that is dangling, but well-aligned.
This is useful for initializing types which lazily allocate, like Vec::new does.
impl<T> Shared<T> where
T: ?Sized,
[src]
const unsafe fn new_unchecked(ptr: *mut T) -> Shared<T>
[src]
Creates a new Shared.
ptr must be non-null.
fn new(ptr: *mut T) -> Option<Shared<T>>
[src]
Creates a new Shared if ptr is non-null.
fn as_ptr(self) -> *mut T
[src]
Acquires the underlying *mut pointer.
unsafe fn as_ref(&self) -> &T
[src]
Dereferences the content.
The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use &*my_ptr.ptr().
unsafe fn as_mut(&mut self) -> &mut T
[src]
Mutably dereferences the content.
The resulting lifetime is bound to self so this behaves "as if" it were actually an instance of T that is getting borrowed. If a longer (unbound) lifetime is needed, use &mut *my_ptr.ptr_mut().
unsafe fn as_mut_ptr(&self) -> *mut T
[src]
Acquires the underlying pointer as a *mut pointer.
impl<T> Clone for Shared<T> where
T: ?Sized,
[src]
fn clone(&self) -> Shared<T>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
impl<'a, T> From<&'a mut T> for Shared<T> where
T: ?Sized,
[src]
fn from(reference: &'a mut T) -> Shared<T>
[src]
Performs the conversion.
impl<T> From<Unique<T>> for Shared<T> where
T: ?Sized,
[src]
fn from(unique: Unique<T>) -> Shared<T>
[src]
Performs the conversion.
impl<'a, T> From<&'a T> for Shared<T> where
T: ?Sized,
[src]
fn from(reference: &'a T) -> Shared<T>
[src]
Performs the conversion.
impl<T> Copy for Shared<T> where
T: ?Sized,
[src]
impl<T> !Send for Shared<T> where
T: ?Sized,
[src]
Shared pointers are not Send because the data they reference may be aliased.
impl<T, U> CoerceUnsized<Shared<U>> for Shared<T> where
T: Unsize<U> + ?Sized,
U: ?Sized,
[src]
impl<T> !Sync for Shared<T> where
T: ?Sized,
[src]
Shared pointers are not Sync because the data they reference may be aliased.
impl<T> Pointer for Shared<T> where
T: ?Sized,
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter.
impl<T: RefUnwindSafe + ?Sized> UnwindSafe for Shared<T>
[src]
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/ptr/struct.Shared.html