[−][src]Struct counting_pointer::Sc
A single-threaded strong reference-counting pointer. 'Sc' stands for 'Strong Counted.'
It behaves like std::rc::Rc
except for that this treats only strong pointer; i.e. Sc
gives
up weak pointer for the performance.
The inherent methods of Sc
are all associated funcitons, which means that you have to call
them as e.g., Sc::get_mut(&mut value)
instead of value.get_mut()
. This avoids conflicts
with methods of the inner type T
.
Implementations
impl<T, A> Sc<T, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
pub fn new(val: T, alloc: A) -> Self
[src]
Creates a new instance.
Examples
use std::alloc::System; use counting_pointer::Sc; let _five = Sc::new(5, System);
pub fn from_slice_alloc(vals: &[T], alloc: A) -> Sc<[T], A> where
T: Clone,
[src]
T: Clone,
Creates a new instance of Sc<[T], A>
.
Examples
use std::alloc::System; use counting_pointer::Sc; let vals: [i32; 4] = [0, 1, 2, 3]; let sc = Sc::from_slice_alloc(&vals, System); assert_eq!(&vals, &*sc);
impl<A> Sc<dyn Any, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
pub fn new_any<T>(val: T, alloc: A) -> Self where
T: Any,
[src]
T: Any,
Creates Sc<dyn Any>
instance.
Examples
use std::alloc::System; use counting_pointer::Sc; let _five = Sc::new_any(5, System);
impl<T, A> Sc<T, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
pub fn to_any(this: Self) -> Sc<dyn Any, A> where
T: Any,
[src]
T: Any,
Consumes this
, returning Sc<dyn Any, A>
Examples
use counting_pointer::Sc; let sc: Sc<i32> = Sc::from(6); let any = Sc::to_any(sc);
impl<T: ?Sized, A> Sc<T, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
pub fn as_ptr(this: &Self) -> *const T
[src]
Provides a raw pointer to the data.
The counts are not affected in any way and the Sc
is not consumed. The pointer is valid
for as long as another Sc
instance is pointing to the address.
Examples
use counting_pointer::Sc; let x: Sc<String> = Sc::from(String::from("Hello")); let x_ptr = Sc::as_ptr(&x); assert_eq!("Hello", unsafe { &*x_ptr });
pub fn count(this: &Self) -> usize
[src]
Returns the number of Sc
pointers pointing to the same address.
Examples
use counting_pointer::Sc; let five: Sc<i32> = Sc::from(5); assert_eq!(1, Sc::count(&five)); let _also_five = five.clone(); assert_eq!(2, Sc::count(&five)); assert_eq!(2, Sc::count(&_also_five)); drop(five); assert_eq!(1, Sc::count(&_also_five));
pub fn get_mut(this: &mut Self) -> Option<&mut T>
[src]
Returns a mutable reference into the given Sc
, if no other Sc
instance is pointing to
the same address; otherwise returns None
.
See also make_mut
, which will clone
the inner value when some other Sc
instances
are.
Examples
use counting_pointer::Sc; let mut x: Sc<i32> = Sc::from(3); assert_eq!(3, *x); *Sc::get_mut(&mut x).unwrap() = 4; assert_eq!(4, *x); let _y = x.clone(); let n = Sc::get_mut(&mut x); assert!(n.is_none());
pub fn ptr_eq(this: &Self, other: &Self) -> bool
[src]
Returns true
if the two Sc
instances point to the same address, or false
.
Examples
use counting_pointer::Sc; let five: Sc<i32> = Sc::from(5); let same_five = five.clone(); let other_five: Sc<i32> = Sc::from(5); assert_eq!(true, Sc::ptr_eq(&five, &same_five)); assert_eq!(false, Sc::ptr_eq(&five, &other_five));
pub fn into_raw_alloc(this: Self) -> (*const T, A)
[src]
Consumes this
, returning the wrapped pointer and the allocator.
To avoid memory leak, the returned pointer must be converted back to an Sc
using
from_raw_alloc
.
Using this function and from_raw_alloc
, user can create an Sc<T: ?Sized>
instance.
Examples
use counting_pointer::Sc; let sc: Sc<String> = Sc::from("Foo".to_string()); let (ptr, alloc) = Sc::into_raw_alloc(sc); let _sc: Sc<dyn AsRef<str>> = unsafe { Sc::from_raw_alloc(ptr, alloc) };
pub unsafe fn from_raw_alloc(ptr: *const T, alloc: A) -> Self
[src]
Constructs a new instance from a raw pointer and allocator.
The raw pointer must have been previously returned by a call to into_raw_alloc
.
Using this function and into_raw_alloc
, user can create an Sc<T: ?Sized>
instance.
Safety
It may lead to memory unsafety to use improperly, even if the returned value will never be accessed.
Examples
use counting_pointer::Sc; let sc: Sc<String> = Sc::from("Foo".to_string()); let (ptr, alloc) = Sc::into_raw_alloc(sc); let _sc: Sc<dyn AsRef<str>> = unsafe { Sc::from_raw_alloc(ptr, alloc) };
impl<T: Clone, A: Clone> Sc<T, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
pub fn make_mut(this: &mut Self) -> &mut T
[src]
Makes a mutable reference into the given Sc
.
If another Sc
instance is pointing to the same address, make_mut
will clone
the inner
value to a new allocation to ensure unique ownership.
See also get_mut
, which will fail rather than cloning.
Examples
use counting_pointer::Sc; let mut data: Sc<i32> = Sc::from(5); assert_eq!(5, *data); *Sc::make_mut(&mut data) += 1; // Won't clone anything. assert_eq!(6, *data); let mut data2 = data.clone(); // Won't clone the inner data. *Sc::make_mut(&mut data) += 1; // Clones inner data. assert_eq!(7, *data); assert_eq!(6, *data2);
impl<A> Sc<dyn Any, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
pub fn downcast<T: Any>(self) -> Result<Sc<T, A>, Self>
[src]
Attempts to downcast the Sc<dyn Any, A>
to a concrete type.
Examples
use std::alloc::System; use std::any::Any; use counting_pointer::Sc; let sc = Sc::new_any(8 as i32, System); let success = Sc::downcast::<i32>(sc.clone()).unwrap(); assert_eq!(8, *success); let fail = Sc::downcast::<String>(sc.clone()); assert_eq!(true, fail.is_err());
Trait Implementations
impl<T: ?Sized, A> AsRef<T> for Sc<T, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
impl<T: ?Sized, A> Borrow<T> for Sc<T, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
impl<T: ?Sized, A> Clone for Sc<T, A> where
A: Clone + GlobalAlloc,
[src]
A: Clone + GlobalAlloc,
fn clone(&self) -> Self
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T: ?Sized, A> Debug for Sc<T, A> where
A: Debug + GlobalAlloc,
[src]
A: Debug + GlobalAlloc,
impl<T, A> Default for Sc<T, A> where
T: Default,
A: Default + GlobalAlloc,
[src]
T: Default,
A: Default + GlobalAlloc,
impl<T: ?Sized, A> Deref for Sc<T, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
impl<T: ?Sized, A> Display for Sc<T, A> where
T: Display,
A: GlobalAlloc,
[src]
T: Display,
A: GlobalAlloc,
impl<T: ?Sized, A> Drop for Sc<T, A> where
A: GlobalAlloc,
[src]
A: GlobalAlloc,
impl<T: ?Sized, A> Eq for Sc<T, A> where
T: Eq,
A: GlobalAlloc,
[src]
T: Eq,
A: GlobalAlloc,
impl<T, A, '_> From<&'_ [T]> for Sc<[T], A> where
T: Clone,
A: Default + GlobalAlloc,
[src]
T: Clone,
A: Default + GlobalAlloc,
impl<T, A> From<T> for Sc<T, A> where
A: Default + GlobalAlloc,
[src]
A: Default + GlobalAlloc,
impl<T: ?Sized, A> Hash for Sc<T, A> where
T: Hash,
A: GlobalAlloc,
[src]
T: Hash,
A: GlobalAlloc,
fn hash<H>(&self, hasher: &mut H) where
H: Hasher,
[src]
H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T: ?Sized, A> Ord for Sc<T, A> where
T: Ord,
A: GlobalAlloc,
[src]
T: Ord,
A: GlobalAlloc,
fn cmp(&self, other: &Self) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<T: ?Sized, A> PartialEq<Sc<T, A>> for Sc<T, A> where
T: PartialEq,
A: GlobalAlloc,
[src]
T: PartialEq,
A: GlobalAlloc,
impl<T: ?Sized, A> PartialOrd<Sc<T, A>> for Sc<T, A> where
T: PartialOrd,
A: GlobalAlloc,
[src]
T: PartialOrd,
A: GlobalAlloc,
Auto Trait Implementations
impl<T: ?Sized, A> RefUnwindSafe for Sc<T, A> where
A: RefUnwindSafe,
T: RefUnwindSafe,
A: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, A = System> !Send for Sc<T, A>
impl<T, A = System> !Sync for Sc<T, A>
impl<T: ?Sized, A> Unpin for Sc<T, A> where
A: Unpin,
A: Unpin,
impl<T: ?Sized, A> UnwindSafe for Sc<T, A> where
A: UnwindSafe,
T: RefUnwindSafe,
A: UnwindSafe,
T: RefUnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<!> for T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,