Struct Sc

Source

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

Expand description

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§

Source §

impl<T, A> Sc<T, A>
where A: GlobalAlloc,

Source

pub fn new(val: T, alloc: A) -> Self

Creates a new instance.

§Examples

use std::alloc::System;
use counting_pointer::Sc;

let _five = Sc::new(5, System);

Source

pub fn from_slice_alloc(vals: &[T], alloc: A) -> Sc<[T], A>
where 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);

Source §

impl<A> Sc<dyn Any, A>
where A: GlobalAlloc,

Source

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

Creates Sc<dyn Any> instance.

§Examples

use std::alloc::System;
use counting_pointer::Sc;

let _five = Sc::new_any(5, System);

Source §

impl<T, A> Sc<T, A>
where A: GlobalAlloc,

Source

pub fn to_any(this: Self) -> Sc<dyn Any, A>
where 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);

Source §

impl<T: ?Sized, A> Sc<T, A>
where A: GlobalAlloc,

Source

pub fn as_ptr(this: &Self) -> *const T

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 });

Source

pub fn count(this: &Self) -> usize

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));

Source

pub fn get_mut(this: &mut Self) -> Option<&mut T>

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());

Source

pub fn ptr_eq(this: &Self, other: &Self) -> bool

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));

Source

pub fn into_raw_alloc(this: Self) -> (*const T, A)

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) };

Source

pub unsafe fn from_raw_alloc(ptr: *const T, alloc: A) -> Self

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) };

Source §

impl<T: Clone, A> Sc<T, A>
where A: GlobalAlloc + Clone,

Source

pub fn make_mut(this: &mut Self) -> &mut T

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);

Source §

impl<A> Sc<dyn Any, A>
where A: GlobalAlloc,

Source

pub fn downcast<T: Any>(self) -> Result<Sc<T, A>, Self>

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());