Struct finarc::FinArc

pub struct FinArc<T, F> where
    T: ?Sized,
    F: FnOnce(&mut T),  { /* fields omitted */ }

Methods

impl<T, F> FinArc<T, F> where
    F: FnOnce(&mut T), 

pub fn new(data: T, finalizer: F) -> Self

pub fn try_unwrap(this: Self) -> Result<T, Self>

Returns the contained value, if this is the last instance of FinArc, without running finalizer

Otherwise, an Err is returned with the same FinArc that was passed in.

Examples

use finarc::FinArc;

let x = FinArc::new(3, |_|{});
assert_eq!(FinArc::try_unwrap(x), Ok(3));

let x = FinArc::new(4, |_|{});
let _y = FinArc::clone(&x);
assert_eq!(*FinArc::try_unwrap(x).unwrap_err(), 4);

Analogue of Arc::try_unwrap

Trait Implementations

impl<T, F> Clone for FinArc<T, F> where
    T: Clone,
    F: FnOnce(&mut T), 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: ?Sized + Debug, F: FnOnce(&mut T)> Debug for FinArc<T, F>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, F> Deref for FinArc<T, F> where
    T: ?Sized,
    F: FnOnce(&mut T), 

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, F> DerefMut for FinArc<T, F> where
    T: ?Sized,
    F: FnOnce(&mut T), 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: ?Sized + Display, F: FnOnce(&mut T)> Display for FinArc<T, F>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, F> Drop for FinArc<T, F> where
    T: ?Sized,
    F: FnOnce(&mut T), 

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ?Sized + Eq, F: FnOnce(&mut T)> Eq for FinArc<T, F>

impl<T: ?Sized + Ord, F: FnOnce(&mut T)> Ord for FinArc<T, F>

fn cmp(&self, other: &FinArc<T, F>) -> Ordering

Comparison for two FinArcs.

The two are compared by calling cmp() on their inner values.

Examples

use finarc::FinArc;
use std::cmp::Ordering;

let five = FinArc::new(5, |_|{});
let mut six = FinArc::clone(&five);
*six = 6;

assert_eq!(Ordering::Less, five.cmp(&six));

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: ?Sized, F, F1> PartialEq<FinArc<T, F1>> for FinArc<T, F> where
    T: PartialEq,
    F: FnOnce(&mut T),
    F1: FnOnce(&mut T), 

We ignore finalizers when comparing FinArc's, so they may be of different types

fn eq(&self, other: &FinArc<T, F1>) -> bool

Equality for two FinArcs.

Two FinArcs are equal if their inner values are equal.

If T also implements Eq, two FinArcs that point to the same value are always equal.

Examples

use finarc::FinArc;

let five = FinArc::new(5, |_|{});

assert!(five == FinArc::new(5, |_|{}));

fn ne(&self, other: &FinArc<T, F1>) -> bool

Inequality for two FinArcs.

Two FinArcs are unequal if their inner values are unequal.

If T also implements Eq, two FinArcs that point to the same value are never unequal.

Examples

use finarc::FinArc;

let five = FinArc::new(5, |_|{});

assert!(five != FinArc::new(6, |_|{}));

impl<T: ?Sized, F, F1> PartialOrd<FinArc<T, F1>> for FinArc<T, F> where
    T: PartialOrd,
    F: FnOnce(&mut T),
    F1: FnOnce(&mut T), 

We ignore finalizers when comparing FinArc's, so they may be of different types

fn partial_cmp(&self, other: &FinArc<T, F1>) -> Option<Ordering>

Partial comparison for two FinArcs.

The two are compared by calling partial_cmp() on their inner values.

Examples

use finarc::FinArc;
use std::cmp::Ordering;

let five = FinArc::new(5, |_|{});

assert_eq!(Some(Ordering::Less), five.partial_cmp(&FinArc::new(6, |_|{})));

fn lt(&self, other: &FinArc<T, F1>) -> bool

Less-than comparison for two FinArcs.

The two are compared by calling < on their inner values.

Examples

use finarc::FinArc;

let five = FinArc::new(5, |_|{});

assert!(five < FinArc::new(6, |_|{}));

fn le(&self, other: &FinArc<T, F1>) -> bool

'Less than or equal to' comparison for two FinArcs.

The two are compared by calling <= on their inner values.

Examples

use finarc::FinArc;

let five = FinArc::new(5, |_|{});

assert!(five <= FinArc::new(5, |_|{}));

fn gt(&self, other: &FinArc<T, F1>) -> bool

Greater-than comparison for two FinArcs.

The two are compared by calling > on their inner values.

Examples

use finarc::FinArc;

let five = FinArc::new(5, |_|{});

assert!(five > FinArc::new(4, |_|{}));

fn ge(&self, other: &FinArc<T, F1>) -> bool

'Greater than or equal to' comparison for two FinArcs.

The two are compared by calling >= on their inner values.

Examples

use finarc::FinArc;

let five = FinArc::new(5, |_|{});

assert!(five >= FinArc::new(5, |_|{}));