Struct State 

#[repr(transparent)]
pub struct State<Q = bool>(pub Q)
where
    Q: ?Sized;

State is a generalized state implementation, representing the state of a system or object.

Tuple Fields

0: Q

Implementations

impl<Q> State<Q>

where Q: RawState,

pub const fn new(state: Q) -> State<Q>

a constructor method for the State type.

pub fn create<F>(f: F) -> State<Q>

where F: FnOnce() -> Q,

generate a new state by invoking the given function and capturing its output.

pub fn one() -> State<Q>

where Q: One,

returns a new state with a value of one.

pub fn zero() -> State<Q>

where Q: Zero,

returns a new state with a value of zero.

pub const fn as_ptr(&self) -> *const Q

returns a new instance of state with a raw pointer to the inner value.

pub const fn as_mut_ptr(&mut self) -> *mut Q

returns a new instance of state with a mutable raw pointer to the inner value.

pub unsafe fn cast<R>(self) -> State<R>

Casts the state to a new type, returning a new instance of State.

Saftey

This method is unsafe because it is up to the caller to ensure that the cast is valid.

pub const fn get(&self) -> &Q

returns an immutable reference to the inner value of the state.

pub const fn get_mut(&mut self) -> &mut Q

returns a mutable reference to the inner value of the state.

pub fn value(self) -> Q

consumes and returns the inner value of the state.

pub fn map<R, F>(self, f: F) -> State<R>

where F: FnOnce(Q) -> R,

State::map applies the given function onto the inner value of the state, returning a new state with the result.

pub const fn replace(&mut self, state: Q) -> Q

replace the inner value of the state with the given state,

pub fn reset(&mut self) -> &mut State<Q>

where Q: Default,

Clears the state, setting it to its default value.

pub fn set(&mut self, state: Q)

update the state with the given value

pub const fn swap(&mut self, other: &mut State<Q>)

swap the inner value of the state with that of the given state.

pub fn take(&mut self) -> Q

where Q: Default,

take the inner value of the state, leaving the logical default in its place

pub fn is_halted(&self) -> bool

where Q: Halt,

returns true if the current state is said to be halted.

pub fn as_halt(&self) -> State<Halter<&Q>>

converts the current reference into a haltable state initialized with the current state

pub fn into_halt(self) -> State<Halter<Q>>

consumes the wrapper to create another, haltable state that is initialized with the current state

pub fn halt(self) -> State<Halter<Q>>

consumes the current state, returning a new one with a Halt variant initialized with the current value.

pub fn boxed(self) -> State<Box<Q>>

returns a new state with a boxed inner value.

pub fn as_any(&self) -> State<Box<dyn Any>>

where Q: Clone + 'static,

Converts the inner type into a boxed “any” state, returning a new instance of state

pub fn into_any(self) -> State<Box<dyn Any>>

where Q: 'static,

Converts the inner type into a boxed “any” state, returning a new instance of state

pub fn shared(self) -> State<Arc<Q>>

Wraps the inner value of the state with an [Arc] and returns a new instance of State

pub fn to_shared(&self) -> State<Arc<Q>>

where Q: Clone,

returns a shared reference to the state.

pub const fn view(&self) -> State<&Q>

returns a state with an owned inner value.

pub const fn view_mut(&mut self) -> State<&mut Q>

returns a state with a mutable reference to the inner value.

pub fn get_inner_type_name(&self) -> &'static str

returns the name of the generic inner type, Q.

pub fn get_inner_type_id(&self) -> TypeId

where Q: 'static,

returns the type id of the generic inner type, Q.

impl<Q> State<&Q>

where Q: RawState,

pub fn cloned(&self) -> State<Q>

where Q: Clone,

Clones the internal state and returning a new instance of State

pub fn copied(&self) -> State<Q>

where Q: Copy,

Copies the internal state and returning a new instance of State

impl<Q> State<&mut Q>

where Q: RawState,

pub fn cloned(&self) -> State<Q>

where Q: Clone,

Clones the internal state and returning a new instance of State

pub fn copied(&self) -> State<Q>

where Q: Copy,

Copies the internal state and returning a new instance of State

impl<Q> State<*const Q>

where Q: RawState,

pub fn from_ptr(ptr: *const Q) -> State<*const Q>

Creates a new instance of state with a raw pointer to the inner value.

impl<Q> State<*mut Q>

where Q: RawState,

pub fn from_mut_ptr(ptr: *mut Q) -> State<*mut Q>

Creates a new instance of state with a mutable raw pointer to the inner value.

impl<Q> State<MaybeUninit<Q>>

where Q: RawState,

pub fn init(value: Q) -> State<MaybeUninit<Q>>

Creates a new instance of state with an initialized inner value.

pub const fn uninit() -> State<MaybeUninit<Q>>

Creates a new instance of state with an uninitialized inner value.

pub unsafe fn assume_init(self) -> State<Q>

Converts the state into a new instance of State with an initialized state.

Safety

This method is unsafe because it is up to the caller to ensure that the inner value is indeed initialized.

pub fn is_null(&self) -> bool

determines if the inner state is null; returns false if the inner state is not null.

pub fn write(&mut self, value: Q) -> &mut Q

Writes a value to the inner state.

impl State<()>

pub const fn empty() -> State<()>

returns a new instance of the state using an empty value.

impl State

pub const fn from_true() -> State

Creates a new instance of State with an inner state of true.

pub const fn from_false() -> State

returns a new instance of State with an inner state of false.

pub fn is_true(&self) -> bool

returns true if the inner state is true, false otherwise.

pub fn is_false(&self) -> bool

returns true if the inner state is false, false otherwise.

impl State<Box<dyn Any>>

pub fn downcast<Q>(self) -> Result<State<Box<Q>>, StateError>

where Q: Any,

Attempts to downcast the state to a concrete type Q; returns an error if the state is not of type Q.

pub fn downcast_ref<Q>(&self) -> Option<State<&Q>>

where Q: Any,

Returns an immutable reference to the state if it is of type Q; returns None otherwise.

pub fn downcast_mut<Q>(&mut self) -> Option<State<&mut Q>>

where Q: Any,

Returns a mutable reference to the state if it is of type Q; returns None otherwise.

impl<Q> State<Option<Q>>

where Q: RawState,

pub const fn none() -> State<Option<Q>>

Creates a new instance of state whose inner state is Option::None.

pub const fn some(value: Q) -> State<Option<Q>>

Creates a new instance of state whose inner state is Option::Some.

Trait Implementations

impl<'a, _A, _B, _C> Add<&'a State<_B>> for &'a State<_A>

where &'a _A: Add<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Add<&'a State<_B>>>::Output

Performs the + operation.

impl<'a, _A, _B, _C> Add<&'a State<_B>> for State<_A>

where _A: Add<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add(self, rhs: &'a State<_B>) -> <State<_A> as Add<&'a State<_B>>>::Output

Performs the + operation.

impl<'a, _A, _B, _C> Add<State<_B>> for &'a State<_A>

where &'a _A: Add<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add(self, rhs: State<_B>) -> <&'a State<_A> as Add<State<_B>>>::Output

Performs the + operation.

impl<_A, _B, _C> Add<State<_B>> for State<_A>

where _A: Add<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add(self, rhs: State<_B>) -> <State<_A> as Add<State<_B>>>::Output

Performs the + operation.

impl<_A, _B> AddAssign<State<_B>> for State<_A>

where _A: AddAssign<_B>,

fn add_assign(&mut self, rhs: State<_B>)

Performs the += operation.

impl<Q> AsMut<Q> for State<Q>

fn as_mut(&mut self) -> &mut Q

Converts this type into a mutable reference of the (usually inferred) input type.

impl<Q> AsRef<Q> for State<Q>

fn as_ref(&self) -> &Q

Converts this type into a shared reference of the (usually inferred) input type.

impl<Q> Binary for State<Q>

where Q: Binary,

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

Formats the value using the given formatter.

impl<'a, _A, _B, _C> BitAnd<&'a State<_B>> for &'a State<_A>

where &'a _A: BitAnd<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as BitAnd<&'a State<_B>>>::Output

Performs the & operation.

impl<'a, _A, _B, _C> BitAnd<&'a State<_B>> for State<_A>

where _A: BitAnd<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand( self, rhs: &'a State<_B>, ) -> <State<_A> as BitAnd<&'a State<_B>>>::Output

Performs the & operation.

impl<'a, _A, _B, _C> BitAnd<State<_B>> for &'a State<_A>

where &'a _A: BitAnd<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand(self, rhs: State<_B>) -> <&'a State<_A> as BitAnd<State<_B>>>::Output

Performs the & operation.

impl<_A, _B, _C> BitAnd<State<_B>> for State<_A>

where _A: BitAnd<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand(self, rhs: State<_B>) -> <State<_A> as BitAnd<State<_B>>>::Output

Performs the & operation.

impl<_A, _B> BitAndAssign<State<_B>> for State<_A>

where _A: BitAndAssign<_B>,

fn bitand_assign(&mut self, rhs: State<_B>)

Performs the &= operation.

impl<'a, _A, _B, _C> BitOr<&'a State<_B>> for &'a State<_A>

where &'a _A: BitOr<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as BitOr<&'a State<_B>>>::Output

Performs the | operation.

impl<'a, _A, _B, _C> BitOr<&'a State<_B>> for State<_A>

where _A: BitOr<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor( self, rhs: &'a State<_B>, ) -> <State<_A> as BitOr<&'a State<_B>>>::Output

Performs the | operation.

impl<'a, _A, _B, _C> BitOr<State<_B>> for &'a State<_A>

where &'a _A: BitOr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor(self, rhs: State<_B>) -> <&'a State<_A> as BitOr<State<_B>>>::Output

Performs the | operation.

impl<_A, _B, _C> BitOr<State<_B>> for State<_A>

where _A: BitOr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor(self, rhs: State<_B>) -> <State<_A> as BitOr<State<_B>>>::Output

Performs the | operation.

impl<_A, _B> BitOrAssign<State<_B>> for State<_A>

where _A: BitOrAssign<_B>,

fn bitor_assign(&mut self, rhs: State<_B>)

Performs the |= operation.

impl<'a, _A, _B, _C> BitXor<&'a State<_B>> for &'a State<_A>

where &'a _A: BitXor<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as BitXor<&'a State<_B>>>::Output

Performs the ^ operation.

impl<'a, _A, _B, _C> BitXor<&'a State<_B>> for State<_A>

where _A: BitXor<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: &'a State<_B>, ) -> <State<_A> as BitXor<&'a State<_B>>>::Output

Performs the ^ operation.

impl<'a, _A, _B, _C> BitXor<State<_B>> for &'a State<_A>

where &'a _A: BitXor<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: State<_B>) -> <&'a State<_A> as BitXor<State<_B>>>::Output

Performs the ^ operation.

impl<_A, _B, _C> BitXor<State<_B>> for State<_A>

where _A: BitXor<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: State<_B>) -> <State<_A> as BitXor<State<_B>>>::Output

Performs the ^ operation.

impl<_A, _B> BitXorAssign<State<_B>> for State<_A>

where _A: BitXorAssign<_B>,

fn bitxor_assign(&mut self, rhs: State<_B>)

Performs the ^= operation.

impl<Q> Borrow<Q> for State<Q>

fn borrow(&self) -> &Q

Immutably borrows from an owned value.

impl<Q> BorrowMut<Q> for State<Q>

fn borrow_mut(&mut self) -> &mut Q

Mutably borrows from an owned value.

impl<Q> Clone for State<Q>

where Q: Clone + ?Sized,

fn clone(&self) -> State<Q>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Q> Debug for State<Q>

where Q: Debug,

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

Formats the value using the given formatter.

impl<Q> Default for State<Q>

where Q: Default + ?Sized,

fn default() -> State<Q>

Returns the “default value” for a type.

impl<Q> Deref for State<Q>

type Target = Q

The resulting type after dereferencing.

fn deref(&self) -> &<State<Q> as Deref>::Target

Dereferences the value.

impl<Q> DerefMut for State<Q>

fn deref_mut(&mut self) -> &mut <State<Q> as Deref>::Target

Mutably dereferences the value.

impl<'de, Q> Deserialize<'de> for State<Q>

where Q: Deserialize<'de> + ?Sized,

fn deserialize<__D>( __deserializer: __D, ) -> Result<State<Q>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Q> Display for State<Q>

where Q: Display,

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

Formats the value using the given formatter.

impl<'a, _A, _B, _C> Div<&'a State<_B>> for &'a State<_A>

where &'a _A: Div<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Div<&'a State<_B>>>::Output

Performs the / operation.

impl<'a, _A, _B, _C> Div<&'a State<_B>> for State<_A>

where _A: Div<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div(self, rhs: &'a State<_B>) -> <State<_A> as Div<&'a State<_B>>>::Output

Performs the / operation.

impl<'a, _A, _B, _C> Div<State<_B>> for &'a State<_A>

where &'a _A: Div<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div(self, rhs: State<_B>) -> <&'a State<_A> as Div<State<_B>>>::Output

Performs the / operation.

impl<_A, _B, _C> Div<State<_B>> for State<_A>

where _A: Div<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div(self, rhs: State<_B>) -> <State<_A> as Div<State<_B>>>::Output

Performs the / operation.

impl<_A, _B> DivAssign<State<_B>> for State<_A>

where _A: DivAssign<_B>,

fn div_assign(&mut self, rhs: State<_B>)

Performs the /= operation.

impl<Q> From<Q> for State<Q>

fn from(state: Q) -> State<Q>

Converts to this type from the input type.

impl<Q> From<State<Q>> for Halter<Q>

fn from(_: State<Q>) -> Halter<Q>

Converts to this type from the input type.

impl<Q> Halt for State<Q>

where Q: RawState + Halt,

fn is_halted(&self) -> bool

impl<Q> Hash for State<Q>

where Q: Hash + ?Sized,

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

where __H: Hasher,

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<Q> LowerExp for State<Q>

where Q: LowerExp,

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

Formats the value using the given formatter.

impl<Q> LowerHex for State<Q>

where Q: LowerHex,

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

Formats the value using the given formatter.

impl<'a, _A, _B, _C> Mul<&'a State<_B>> for &'a State<_A>

where &'a _A: Mul<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Mul<&'a State<_B>>>::Output

Performs the * operation.

impl<'a, _A, _B, _C> Mul<&'a State<_B>> for State<_A>

where _A: Mul<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a State<_B>) -> <State<_A> as Mul<&'a State<_B>>>::Output

Performs the * operation.

impl<'a, _A, _B, _C> Mul<State<_B>> for &'a State<_A>

where &'a _A: Mul<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul(self, rhs: State<_B>) -> <&'a State<_A> as Mul<State<_B>>>::Output

Performs the * operation.

impl<_A, _B, _C> Mul<State<_B>> for State<_A>

where _A: Mul<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul(self, rhs: State<_B>) -> <State<_A> as Mul<State<_B>>>::Output

Performs the * operation.

impl<_A, _B> MulAssign<State<_B>> for State<_A>

where _A: MulAssign<_B>,

fn mul_assign(&mut self, rhs: State<_B>)

Performs the *= operation.

impl<'a, _A, _B> Neg for &'a State<_A>

where &'a _A: Neg<Output = _B>,

type Output = State<_B>

The resulting type after applying the - operator.

fn neg(self) -> <&'a State<_A> as Neg>::Output

Performs the unary - operation.

impl<'a, _A, _B> Neg for &'a mut State<_A>

where &'a mut _A: Neg<Output = _B>,

type Output = State<_B>

The resulting type after applying the - operator.

fn neg(self) -> <&'a mut State<_A> as Neg>::Output

Performs the unary - operation.

impl<_A, _B> Neg for State<_A>

where _A: Neg<Output = _B>,

type Output = State<_B>

The resulting type after applying the - operator.

fn neg(self) -> <State<_A> as Neg>::Output

Performs the unary - operation.

impl<'a, _A, _B> Not for &'a State<_A>

where &'a _A: Not<Output = _B>,

type Output = State<_B>

The resulting type after applying the ! operator.

fn not(self) -> <&'a State<_A> as Not>::Output

Performs the unary ! operation.

impl<'a, _A, _B> Not for &'a mut State<_A>

where &'a mut _A: Not<Output = _B>,

type Output = State<_B>

The resulting type after applying the ! operator.

fn not(self) -> <&'a mut State<_A> as Not>::Output

Performs the unary ! operation.

impl<_A, _B> Not for State<_A>

where _A: Not<Output = _B>,

type Output = State<_B>

The resulting type after applying the ! operator.

fn not(self) -> <State<_A> as Not>::Output

Performs the unary ! operation.

impl<Q> Num for State<Q>

where Q: RawState + Num,

type FromStrRadixErr = <Q as Num>::FromStrRadixErr

fn from_str_radix( str: &str, radix: u32, ) -> Result<State<Q>, <State<Q> as Num>::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl<Q> Octal for State<Q>

where Q: Octal,

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

Formats the value using the given formatter.

impl<Q> One for State<Q>

where Q: RawState + PartialEq + One,

fn one() -> State<Q>

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<Q> Ord for State<Q>

where Q: Ord + ?Sized,

fn cmp(&self, other: &State<Q>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a, Q> PartialEq<&'a Q> for State<Q>

where Q: PartialEq,

fn eq(&self, other: &&'a Q) -> 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<'a, Q> PartialEq<&'a mut Q> for State<Q>

where Q: PartialEq,

fn eq(&self, other: &&'a mut Q) -> 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<Q, S> PartialEq<Head<Q, S>> for State<&Q>

where Q: RawState + PartialEq,

fn eq(&self, head: &Head<Q, S>) -> 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<Q, S> PartialEq<Head<Q, S>> for State<Q>

where Q: RawState + PartialEq,

fn eq(&self, head: &Head<Q, S>) -> 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<Q> PartialEq<Q> for State<Q>

where Q: PartialEq,

fn eq(&self, other: &Q) -> 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<'a, Q, S> PartialEq<State<&'a Q>> for Head<Q, S>

where Q: RawState + PartialEq,

fn eq(&self, state: &State<&'a Q>) -> 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<Q, S> PartialEq<State<Q>> for Head<Q, S>

where Q: RawState + PartialEq,

fn eq(&self, state: &State<Q>) -> 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<Q> PartialEq for State<Q>

where Q: PartialEq + ?Sized,

fn eq(&self, other: &State<Q>) -> 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<'a, Q> PartialOrd<&'a Q> for State<Q>

where Q: PartialOrd,

fn partial_cmp(&self, other: &&'a Q) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, Q> PartialOrd<&'a mut Q> for State<Q>

where Q: PartialOrd,

fn partial_cmp(&self, other: &&'a mut Q) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Q> PartialOrd<Q> for State<Q>

where Q: PartialOrd,

fn partial_cmp(&self, other: &Q) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Q> PartialOrd for State<Q>

where Q: PartialOrd + ?Sized,

fn partial_cmp(&self, other: &State<Q>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, _A, _B, _C> Rem<&'a State<_B>> for &'a State<_A>

where &'a _A: Rem<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Rem<&'a State<_B>>>::Output

Performs the % operation.

impl<'a, _A, _B, _C> Rem<&'a State<_B>> for State<_A>

where _A: Rem<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a State<_B>) -> <State<_A> as Rem<&'a State<_B>>>::Output

Performs the % operation.

impl<'a, _A, _B, _C> Rem<State<_B>> for &'a State<_A>

where &'a _A: Rem<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem(self, rhs: State<_B>) -> <&'a State<_A> as Rem<State<_B>>>::Output

Performs the % operation.

impl<_A, _B, _C> Rem<State<_B>> for State<_A>

where _A: Rem<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem(self, rhs: State<_B>) -> <State<_A> as Rem<State<_B>>>::Output

Performs the % operation.

impl<_A, _B> RemAssign<State<_B>> for State<_A>

where _A: RemAssign<_B>,

fn rem_assign(&mut self, rhs: State<_B>)

Performs the %= operation.

impl<Q> Serialize for State<Q>

where Q: Serialize + ?Sized,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, _A, _B, _C> Shl<&'a State<_B>> for &'a State<_A>

where &'a _A: Shl<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Shl<&'a State<_B>>>::Output

Performs the << operation.

impl<'a, _A, _B, _C> Shl<&'a State<_B>> for State<_A>

where _A: Shl<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a State<_B>) -> <State<_A> as Shl<&'a State<_B>>>::Output

Performs the << operation.

impl<'a, _A, _B, _C> Shl<State<_B>> for &'a State<_A>

where &'a _A: Shl<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl(self, rhs: State<_B>) -> <&'a State<_A> as Shl<State<_B>>>::Output

Performs the << operation.

impl<_A, _B, _C> Shl<State<_B>> for State<_A>

where _A: Shl<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl(self, rhs: State<_B>) -> <State<_A> as Shl<State<_B>>>::Output

Performs the << operation.

impl<_A, _B> ShlAssign<State<_B>> for State<_A>

where _A: ShlAssign<_B>,

fn shl_assign(&mut self, rhs: State<_B>)

Performs the <<= operation.

impl<'a, _A, _B, _C> Shr<&'a State<_B>> for &'a State<_A>

where &'a _A: Shr<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Shr<&'a State<_B>>>::Output

Performs the >> operation.

impl<'a, _A, _B, _C> Shr<&'a State<_B>> for State<_A>

where _A: Shr<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a State<_B>) -> <State<_A> as Shr<&'a State<_B>>>::Output

Performs the >> operation.

impl<'a, _A, _B, _C> Shr<State<_B>> for &'a State<_A>

where &'a _A: Shr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr(self, rhs: State<_B>) -> <&'a State<_A> as Shr<State<_B>>>::Output

Performs the >> operation.

impl<_A, _B, _C> Shr<State<_B>> for State<_A>

where _A: Shr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr(self, rhs: State<_B>) -> <State<_A> as Shr<State<_B>>>::Output

Performs the >> operation.

impl<_A, _B> ShrAssign<State<_B>> for State<_A>

where _A: ShrAssign<_B>,

fn shr_assign(&mut self, rhs: State<_B>)

Performs the >>= operation.

impl<Q> StateRepr<Q> for State<Q>

where Q: RawState,

type Repr<_V: RawState> = State<_V>

fn get(&self) -> &Q

return a reference to the underlying state

fn get_mut(&mut self) -> &mut Q

return a mutable reference to the underlying state

fn view(&self) -> <State<Q> as StateRepr<Q>>::Repr<&Q>

returns a view of the representation using a reference to the current value

fn view_mut(&mut self) -> <State<Q> as StateRepr<Q>>::Repr<&mut Q>

returns a view of the representation containing a mutable reference to the current value

fn replace(&mut self, value: U) -> U

replace the inner value with another value, returning the old value

fn set(&mut self, value: U)

update the inner value

fn swap(&mut self, other: &mut Self)

swap the inner value with another value

fn take(&mut self) -> U

where U: Default,

take the inner value, leaving a default value in its place

impl<'a, _A, _B, _C> Sub<&'a State<_B>> for &'a State<_A>

where &'a _A: Sub<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Sub<&'a State<_B>>>::Output

Performs the - operation.

impl<'a, _A, _B, _C> Sub<&'a State<_B>> for State<_A>

where _A: Sub<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a State<_B>) -> <State<_A> as Sub<&'a State<_B>>>::Output

Performs the - operation.

impl<'a, _A, _B, _C> Sub<State<_B>> for &'a State<_A>

where &'a _A: Sub<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub(self, rhs: State<_B>) -> <&'a State<_A> as Sub<State<_B>>>::Output

Performs the - operation.

impl<_A, _B, _C> Sub<State<_B>> for State<_A>

where _A: Sub<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub(self, rhs: State<_B>) -> <State<_A> as Sub<State<_B>>>::Output

Performs the - operation.

impl<_A, _B> SubAssign<State<_B>> for State<_A>

where _A: SubAssign<_B>,

fn sub_assign(&mut self, rhs: State<_B>)

Performs the -= operation.

impl<Q> UpperExp for State<Q>

where Q: UpperExp,

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

Formats the value using the given formatter.

impl<Q> UpperHex for State<Q>

where Q: UpperHex,

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

Formats the value using the given formatter.

impl<Q> Zero for State<Q>

where Q: RawState + Zero,

fn zero() -> State<Q>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<Q> Copy for State<Q>

where Q: Copy + ?Sized,

impl<Q> Eq for State<Q>

where Q: Eq + ?Sized,

impl<Q> Send for State<Q>

where Q: Send,

impl<Q> StructuralPartialEq for State<Q>

where Q: ?Sized,

impl<Q> Sync for State<Q>

where Q: Sync,