Struct Repr

pub struct Repr<T: Debug, I: Fn(&T) -> bool> { /* private fields */ }

Wraps a value and ensures that an invariant is maintained while allowing that value to be mutated. The invariant is checked after every mutation. See crate::CacheableRepr for a version of this struct that supports caching.

Implementations

impl<T: Debug, I: Fn(&T) -> bool> Repr<T, I>

pub const fn new(inner: T, invariant: I) -> Self

Creates a new representation invariant with the given value and invariant function.

use repr_rs::Repr;
struct MinMax { min: i32, max: i32 }
Repr::new(
  MinMax { min: 1, max: 5 },
  |mm| mm.min < mm.max,
);

pub const fn with_msg( inner: T, invariant: I, violation_message: &'static str, ) -> Self

Creates a new representation invariant with the given value, invariant function, and violation message.

use repr_rs::Repr;
struct MinMax { min: i32, max: i32 }
Repr::with_msg(
  MinMax { min: 1, max: 5 },
  |mm| mm.min < mm.max,
  "min must be less than max",
);

pub fn read(&self) -> &T

Borrows a read-only view of the value in the representation invariant.

use repr_rs::Repr;
struct MinMax { min: i32, max: i32 }
let repr = Repr::new(MinMax { min: 1, max: 5 }, |mm| mm.min < mm.max);
let view = repr.read();
assert_eq!(1, view.min);
assert_eq!(5, view.max);

pub fn write(&mut self) -> ReprMutator<'_, T, I>

Borrows a mutable view of the value in the representation invariant.

use repr_rs::Repr;
struct MinMax { min: i32, max: i32 }
let mut repr = Repr::new(MinMax { min: 1, max: 5 }, |mm| mm.min < mm.max);
{
  let view = repr.read();
  assert_eq!(1, view.min);
  assert_eq!(5, view.max);
}
repr.write().min = 4;
let view = repr.read();
assert_eq!(4, view.min);
assert_eq!(5, view.max);

Rust’s borrowing rules prevent the read-only view being held while a mutation occurs. For example, this won’t compile:

use repr_rs::Repr;
struct MinMax { min: i32, max: i32 }
let mut repr = Repr::new(MinMax { min: 1, max: 5 }, |mm| mm.min < mm.max);
let view = repr.borrow();
assert_eq!(1, view.min);
assert_eq!(5, view.max);
// error[E0502]: cannot borrow `repr` as mutable because it is also borrowed as immutable
repr.borrow_mut().min = 4;
assert_eq!(4, view.min);
assert_eq!(5, view.max);

pub fn into_inner(self) -> T

Consumes the representation invariant and returns the inner value.

use repr_rs::Repr;
struct MinMax { min: i32, max: i32 }
let repr = Repr::new(MinMax { min: 1, max: 5 }, |mm| mm.min < mm.max);
let inner = repr.into_inner();
assert_eq!(1, inner.min);

Trait Implementations

impl<T: Debug + Clone, I: Fn(&T) -> bool + Clone> Clone for Repr<T, I>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, I: Fn(&T) -> bool> Debug for Repr<T, I>

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

Formats the value using the given formatter.

impl<T: Debug + Display, I: Fn(&T) -> bool> Display for Repr<T, I>

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

Formats the value using the given formatter.

impl<T: Debug + 'static, I: Fn(&T) -> bool> From<CacheableRepr<T, I>> for Repr<T, I>

fn from(value: CacheableRepr<T, I>) -> Self

Converts to this type from the input type.

impl<T: Debug + 'static, I: Fn(&T) -> bool> From<Repr<T, I>> for CacheableRepr<T, I>

fn from(value: Repr<T, I>) -> Self

Converts to this type from the input type.

impl<T: Debug + Hash, I: Fn(&T) -> bool> Hash for Repr<T, I>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Debug + PartialEq, I: Fn(&T) -> bool> PartialEq for Repr<T, I>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Debug + Eq, I: Fn(&T) -> bool> Eq for Repr<T, I>