Struct bitflags::__core::ptr::Shared
[−]
[src]
pub struct Shared<T> where T: ?Sized {
// some fields omitted
}
shared
): needs an RFC to flesh out design
A wrapper around a raw non-null *mut T
that indicates that the possessor
of this wrapper has shared ownership of the referent. Useful for
building abstractions like Rc<T>
or Arc<T>
, which internally
use raw pointers to manage the memory that they own.
Methods
impl<T> Shared<T> where T: ?Sized
Methods from Deref<Target=*mut T>
1.0.0[−]fn is_null(self) -> bool
Returns true if the pointer is null.
Examples
Basic usage:
let mut s = [1, 2, 3]; let ptr: *mut u32 = s.as_mut_ptr(); assert!(ptr.is_null() == false);
unsafe fn as_ref(&self) -> Option<&'a T>
[−]
ptr_as_ref
): Option is not clearly the right return type, and we may want to tie the return lifetime to a borrow of the raw pointer
Returns None
if the pointer is null, or else returns a reference to
the value wrapped in Some
.
Safety
While this method and its mutable counterpart are useful for null-safety, it is important to note that this is still an unsafe operation because the returned value could be pointing to invalid memory.
Examples
Basic usage:
let val: *mut u8 = &mut 10u8 as *mut u8; unsafe { if let Some(val_back) = val.as_ref() { println!("We got back the value: {}!", val_back); } }
1.0.0[−]unsafe fn offset(self, count: isize) -> *mut T
Calculates the offset from a pointer. count
is in units of T; e.g. a
count
of 3 represents a pointer offset of 3 * sizeof::<T>()
bytes.
Safety
The offset must be in-bounds of the object, or one-byte-past-the-end.
Otherwise offset
invokes Undefined Behavior, regardless of whether
the pointer is used.
Examples
Basic usage:
let mut s = [1, 2, 3]; let ptr: *mut u32 = s.as_mut_ptr(); unsafe { println!("{}", *ptr.offset(1)); println!("{}", *ptr.offset(2)); }
unsafe fn as_mut(&self) -> Option<&'a mut T>
[−]
ptr_as_ref
): return value does not necessarily convey all possible information
1.0.0[−]fn is_null(self) -> bool
Returns true if the pointer is null.
Examples
Basic usage:
let s: &str = "Follow the rabbit"; let ptr: *const u8 = s.as_ptr(); assert!(ptr.is_null() == false);
unsafe fn as_ref(&self) -> Option<&'a T>
[−]
ptr_as_ref
): Option is not clearly the right return type, and we may want to tie the return lifetime to a borrow of the raw pointer
Returns None
if the pointer is null, or else returns a reference to
the value wrapped in Some
.
Safety
While this method and its mutable counterpart are useful for null-safety, it is important to note that this is still an unsafe operation because the returned value could be pointing to invalid memory.
Examples
Basic usage:
let val: *const u8 = &10u8 as *const u8; unsafe { if let Some(val_back) = val.as_ref() { println!("We got back the value: {}!", val_back); } }
1.0.0[−]unsafe fn offset(self, count: isize) -> *const T
Calculates the offset from a pointer. count
is in units of T; e.g. a
count
of 3 represents a pointer offset of 3 * sizeof::<T>()
bytes.
Safety
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object. If either pointer is out of bounds or arithmetic overflow occurs then any further use of the returned value will result in undefined behavior.
Examples
Basic usage:
let s: &str = "123"; let ptr: *const u8 = s.as_ptr(); unsafe { println!("{}", *ptr.offset(1) as char); println!("{}", *ptr.offset(2) as char); }
Trait Implementations
impl<T> Deref for Shared<T> where T: ?Sized
impl<T, U> CoerceUnsized<Shared<U>> for Shared<T> where T: Unsize<U> + ?Sized, U: ?Sized
impl<T> Copy for Shared<T> where T: ?Sized
impl<T> Clone for Shared<T> where T: ?Sized
fn clone(&self) -> Shared<T>
1.0.0fn clone_from(&mut self, source: &Self)
impl<T> !Send for Shared<T> where T: ?Sized
Shared
pointers are not Send
because the data they reference may be aliased.
impl<T> !Sync for Shared<T> where T: ?Sized
Shared
pointers are not Sync
because the data they reference may be aliased.