[][src]Struct counting_pointer::Sc

pub struct Sc<T: ?Sized, A = System> where
    A: GlobalAlloc
{ /* fields omitted */ }

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]

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]

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]

pub fn new_any<T>(val: T, alloc: A) -> Self where
    T: Any
[src]

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]

pub fn to_any(this: Self) -> Sc<dyn Any, A> where
    T: Any
[src]

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]

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]

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]

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]

impl<T: ?Sized, A> Borrow<T> for Sc<T, A> where
    A: GlobalAlloc
[src]

impl<T: ?Sized, A> Clone for Sc<T, A> where
    A: Clone + GlobalAlloc
[src]

impl<T: ?Sized, A> Debug for Sc<T, A> where
    A: Debug + GlobalAlloc
[src]

impl<T, A> Default for Sc<T, A> where
    T: Default,
    A: Default + GlobalAlloc
[src]

impl<T: ?Sized, A> Deref for Sc<T, A> where
    A: GlobalAlloc
[src]

type Target = T

The resulting type after dereferencing.

impl<T: ?Sized, A> Display for Sc<T, A> where
    T: Display,
    A: GlobalAlloc
[src]

impl<T: ?Sized, A> Drop for Sc<T, A> where
    A: GlobalAlloc
[src]

impl<T: ?Sized, A> Eq for Sc<T, A> where
    T: Eq,
    A: GlobalAlloc
[src]

impl<T, A, '_> From<&'_ [T]> for Sc<[T], A> where
    T: Clone,
    A: Default + GlobalAlloc
[src]

impl<T, A> From<T> for Sc<T, A> where
    A: Default + GlobalAlloc
[src]

impl<T: ?Sized, A> Hash for Sc<T, A> where
    T: Hash,
    A: GlobalAlloc
[src]

impl<T: ?Sized, A> Ord for Sc<T, A> where
    T: Ord,
    A: GlobalAlloc
[src]

impl<T: ?Sized, A> PartialEq<Sc<T, A>> for Sc<T, A> where
    T: PartialEq,
    A: GlobalAlloc
[src]

impl<T: ?Sized, A> PartialOrd<Sc<T, A>> for Sc<T, A> where
    T: PartialOrd,
    A: GlobalAlloc
[src]

Auto Trait Implementations

impl<T: ?Sized, A> RefUnwindSafe for Sc<T, A> where
    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

impl<T: ?Sized, A> UnwindSafe for Sc<T, A> where
    A: UnwindSafe,
    T: RefUnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[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]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.