Struct static_rc::StaticRc [−][src]
pub struct StaticRc<T: ?Sized, const NUM: usize, const DEN: usize> { /* fields omitted */ }
A compile-time reference-counted pointer.
The inherent methods of StaticRc
are all associated functions to avoid conflicts with the the methods of the
inner type T
which are brought into scope by the Deref
implementation.
The parameters NUM
and DEN
DENote the ratio (NUM / DEN
) of ownership of the pointer:
- The ratio is always in the (0, 1] interval, that is:
NUM > 0
andNUM <= DEN
. - When the ratio is equal to 1, that is when
NUM == DEN
, then the instance has full ownership of the pointee and extra capabilities are unlocked.
Implementations
impl<T: ?Sized, const NUM: usize, const DEN: usize> StaticRc<T, NUM, DEN>
[src]
impl<T: ?Sized, const NUM: usize, const DEN: usize> StaticRc<T, NUM, DEN>
[src]pub fn into_raw(this: Self) -> NonNull<T>
[src]
Consumes the StaticRc
, returning the wrapped pointer.
To avoid a memory leak, the pointer must be converted back to Self
using StaticRc::from_raw
.
pub fn as_ptr(this: &Self) -> NonNull<T>
[src]
Provides a raw pointer to the data.
StaticRc
is not consumed or affected in any way, the pointer is valid as long as there are shared owners of
the value.
pub fn get_ref(this: &Self) -> &T
[src]
Provides a reference to the data.
pub unsafe fn from_raw(pointer: NonNull<T>) -> Self
[src]
Constructs a StaticRc<T, NUM, DEN>
from a raw pointer.
The raw pointer must have been previously returned by a call to StaticRc<U, N, D>::into_raw
:
- If
U
is different fromT
, then specific restrictions on size and alignment apply. Seemem::transmute
for the restrictions applying to transmuting references. - If
N / D
is different fromNUM / DEN
, then specific restrictions apply. The user is responsible for ensuring proper management of the ratio of shares, and ultimately that the value is not dropped twice.
pub fn ptr_eq<const N: usize, const D: usize>(
this: &Self,
other: &StaticRc<T, N, D>
) -> bool
[src]
this: &Self,
other: &StaticRc<T, N, D>
) -> bool
Returns true if the two StaticRc
point to the same allocation.
pub fn adjust<const N: usize, const D: usize>(this: Self) -> StaticRc<T, N, D>ⓘ where
((), ()): Sized,
[src]
((), ()): Sized,
Adjusts the NUMerator and DENUMerator of the ratio of the instance, preserving the ratio.
Panics
If the compile-time-ratio feature is not used, and the ratio is not preserved; that is N / D <> NUM / DEN
.
pub fn split<const A: usize, const B: usize>(
this: Self
) -> (StaticRc<T, A, DEN>, StaticRc<T, B, DEN>) where
((), ()): Sized,
[src]
this: Self
) -> (StaticRc<T, A, DEN>, StaticRc<T, B, DEN>) where
((), ()): Sized,
Splits the current instance into two instances with the specified NUMerators.
Panics
If the compile-time-ratio feature is not used, and the ratio is not preserved; that is A + B <> NUM
.
pub fn split_array<const N: usize, const D: usize, const DIM: usize>(
this: Self
) -> [StaticRc<T, N, D>; DIM] where
((), ()): Sized,
(): Sized,
[src]
this: Self
) -> [StaticRc<T, N, D>; DIM] where
((), ()): Sized,
(): Sized,
Splits the current instance into DIM
instances with the specified Numerators and Denominators.
Panics
If the compile-time-ratio feature is not used, and the ratio is not preserved; that is N * DIM / D <> NUM / DEN
.
pub fn join<const A: usize, const B: usize>(
left: StaticRc<T, A, DEN>,
right: StaticRc<T, B, DEN>
) -> Self where
((), ()): Sized,
[src]
left: StaticRc<T, A, DEN>,
right: StaticRc<T, B, DEN>
) -> Self where
((), ()): Sized,
Joins two instances into a single instance.
Panics
If the two instances do no point to the same allocation, as determined by StaticRc::ptr_eq
.
If the compile-time-ratio feature is not used and the ratio is not preserved; that is A + B <> NUM
.
pub unsafe fn join_unchecked<const A: usize, const B: usize>(
left: StaticRc<T, A, DEN>,
right: StaticRc<T, B, DEN>
) -> Self where
((), ()): Sized,
[src]
left: StaticRc<T, A, DEN>,
right: StaticRc<T, B, DEN>
) -> Self where
((), ()): Sized,
Joins two instances into a single instance without checking whether they point to the same allocation.
Unless compile-time-ratio
is activated, the ratios are checked nevertheless.
Safety
The caller must guarantee that those instances point to the same allocation.
Panics
If the compile-time-ratio feature is not used and the ratio is not preserved; that is A + B <> NUM
.
Trait Implementations
impl<T: ?Sized, const N: usize> BorrowMut<T> for StaticRc<T, N, N>
[src]
impl<T: ?Sized, const N: usize> BorrowMut<T> for StaticRc<T, N, N>
[src]fn borrow_mut(&mut self) -> &mut T
[src]
impl<T: ?Sized + Display, const NUM: usize, const DEN: usize> Display for StaticRc<T, NUM, DEN>
[src]
impl<T: ?Sized + Display, const NUM: usize, const DEN: usize> Display for StaticRc<T, NUM, DEN>
[src]impl<I: DoubleEndedIterator + ?Sized, const N: usize> DoubleEndedIterator for StaticRc<I, N, N>
[src]
impl<I: DoubleEndedIterator + ?Sized, const N: usize> DoubleEndedIterator for StaticRc<I, N, N>
[src]fn next_back(&mut self) -> Option<I::Item>
[src]
fn nth_back(&mut self, n: usize) -> Option<I::Item>
[src]
pub fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]
pub fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
pub fn rfold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.27.0[src]
F: FnMut(B, Self::Item) -> B,
pub fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.27.0[src]
P: FnMut(&Self::Item) -> bool,
impl<I: ExactSizeIterator + ?Sized, const N: usize> ExactSizeIterator for StaticRc<I, N, N>
[src]
impl<I: ExactSizeIterator + ?Sized, const N: usize> ExactSizeIterator for StaticRc<I, N, N>
[src]impl<const NUM: usize, const DEN: usize> From<StaticRc<str, NUM, DEN>> for StaticRc<[u8], NUM, DEN>
[src]
impl<const NUM: usize, const DEN: usize> From<StaticRc<str, NUM, DEN>> for StaticRc<[u8], NUM, DEN>
[src]impl<T, const N: usize> FromIterator<T> for StaticRc<[T], N, N>
[src]
impl<T, const N: usize> FromIterator<T> for StaticRc<[T], N, N>
[src]fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self
[src]
impl<I: FusedIterator + ?Sized, const N: usize> FusedIterator for StaticRc<I, N, N>
[src]
impl<I: FusedIterator + ?Sized, const N: usize> FusedIterator for StaticRc<I, N, N>
[src]impl<I: Iterator + ?Sized, const N: usize> Iterator for StaticRc<I, N, N>
[src]
impl<I: Iterator + ?Sized, const N: usize> Iterator for StaticRc<I, N, N>
[src]type Item = I::Item
The type of the elements being iterated over.
fn next(&mut self) -> Option<I::Item>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
fn nth(&mut self, n: usize) -> Option<I::Item>
[src]
fn last(self) -> Option<I::Item>
[src]
pub fn count(self) -> usize
1.0.0[src]
pub fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
pub fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
pub fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]
U: IntoIterator<Item = Self::Item>,
pub fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
U: IntoIterator,
pub fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
pub fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]
G: FnMut() -> Self::Item,
pub fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]
F: FnMut(Self::Item) -> B,
pub fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
pub fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(Self::Item) -> Option<B>,
pub fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
pub fn peekable(self) -> Peekable<Self>
1.0.0[src]
pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]
P: FnMut(Self::Item) -> Option<B>,
pub fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]
pub fn take(self, n: usize) -> Take<Self>
1.0.0[src]
pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
pub fn fuse(self) -> Fuse<Self>
1.0.0[src]
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
F: FnMut(&Self::Item),
pub fn by_ref(&mut self) -> &mut Self
1.0.0[src]
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]pub fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
1.0.0[src]
B: FromIterator<Self::Item>,
pub fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
1.0.0[src]
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
pub fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
[src]
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
pub fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
pub fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
pub fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
pub fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.0.0[src]
F: FnMut(B, Self::Item) -> B,
pub fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
pub fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
pub fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
pub fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
[src]
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
pub fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]
P: FnMut(Self::Item) -> bool,
pub fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
1.0.0[src]
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
pub fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
pub fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
pub fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
pub fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
pub fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]
Self: DoubleEndedIterator,
pub fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
1.0.0[src]
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
pub fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
pub fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
pub fn cycle(self) -> Cycle<Self> where
Self: Clone,
1.0.0[src]
Self: Clone,
pub fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
pub fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
pub fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
pub fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
pub fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
pub fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
pub fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
pub fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
pub fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
pub fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
pub fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
impl<T: ?Sized, const NUM: usize, const DEN: usize, const N: usize, const D: usize> PartialEq<StaticRc<T, N, D>> for StaticRc<T, NUM, DEN> where
T: PartialEq<T>,
[src]
impl<T: ?Sized, const NUM: usize, const DEN: usize, const N: usize, const D: usize> PartialEq<StaticRc<T, N, D>> for StaticRc<T, NUM, DEN> where
T: PartialEq<T>,
[src]impl<T: ?Sized, const NUM: usize, const DEN: usize, const N: usize, const D: usize> PartialOrd<StaticRc<T, N, D>> for StaticRc<T, NUM, DEN> where
T: PartialOrd<T>,
[src]
impl<T: ?Sized, const NUM: usize, const DEN: usize, const N: usize, const D: usize> PartialOrd<StaticRc<T, N, D>> for StaticRc<T, NUM, DEN> where
T: PartialOrd<T>,
[src]Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<F> IntoFuture for F where
F: Future,
[src]
impl<F> IntoFuture for F where
F: Future,
[src]type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type Future = F
into_future
)Which kind of future are we turning this into?
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]