Struct changed::Cd

pub struct Cd<T> { /* fields omitted */ }

Cd: Change Detection

Start by creating one with new().

Implementations

impl<T> Cd<T>

pub fn new(data: T) -> Cd<T>

Create a new Cd with data. It is initialized to false for change detection.

use changed::Cd;
let cd = Cd::new(5);

pub fn new_true(data: T) -> Cd<T>

Create a new Cd with data. It is initialized to true for change detection.

use changed::Cd;
let cd = Cd::new_true(5);
assert!(cd.changed());

pub fn reset(&mut self)

Reset the change tracking to false.

use changed::Cd;
let mut cd = Cd::new_true(5);
cd.reset();
assert!(!cd.changed());

pub fn take(self) -> T

Take the data out of the Cd. Consumes self and returns data.

use changed::Cd;
let cd = Cd::new(5);
let data = cd.take();
// Error: cd has been moved.
// cd.changed();

pub fn changed(&self) -> bool

Check if the Cd has been changed since the last call to reset (or created.)

use changed::Cd;
let mut cd = Cd::new(5);
assert!(!cd.changed());
*cd += 5;
assert!(cd.changed());

pub fn mutate_silently(&mut self) -> &mut T

Mutate the Cd without tripping change detection.

use changed::Cd;
let mut cd = Cd::new(5);
*cd.mutate_silently() += 5;
assert!(!cd.changed());

Trait Implementations

impl<T: Default> Default for Cd<T>

Impl default where the data impls default. Change detection is initialized to false.

use changed::Cd;
// 0 is default for i32.
let zero: Cd<i32> = Cd::default();
assert!(!zero.changed());

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for Cd<T>

deref does not trip change detection.

use changed::Cd;
let cd = Cd::new(5);
assert_eq!(*cd, 5); // deref for == 5
assert!(!cd.changed()); // .changed() is false

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Cd<T>

deref_mut trips change detection.

use changed::Cd;
let mut cd = Cd::new(5);
*cd += 5; // deref_mut for add assign
assert_eq!(*cd, 10);
assert!(cd.changed()); // .changed() is true

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

Mutably dereferences the value.