Struct State 

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

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

Tuple Fields

0: Q

Implementations

impl<Q> State<Q>

pub const fn new(state: Q) -> Self

a constructor method for the State type.

pub fn create<F>(f: F) -> Self

where F: FnOnce() -> Q,

initializes a new instance of state using the given initializer function.

pub fn one() -> Self

where Q: One,

returns a new state with a value of one.

pub fn zero() -> Self

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 Self

where Q: Default,

Clears the state, setting it to its default value.

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

Sets the state to a new 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 as_halt(&self) -> State<Halt<&Q>>

returns a halted state with an immutable reference to the state.

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

Consumes the state and returns a halted state.

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

Wraps the inner value with a Halt state, returning a new instance of State.

pub fn is_halt(&self) -> bool

where Q: 'static,

returns true if the state is a Halt state.

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>

pub fn into_inner(self) -> Q

👎Deprecated since 0.0.7: use value instead, as it is more idiomatic and clearer.

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

👎Deprecated since 0.0.7: use view instead, as it is more idiomatic and clearer.

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

👎Deprecated since 0.0.7: use view_mut instead, as it is more idiomatic and clearer.

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) -> Self

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) -> Self

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) -> Self

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

pub const fn uninit() -> Self

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() -> Self

Creates a new instance of State with an empty state.

impl State<bool>

pub const fn from_true() -> Self

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

pub const fn from_false() -> Self

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>>, Error>

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() -> Self

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

pub const fn some(value: Q) -> Self

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

impl<Q> State<Halt<Q>>

where Q: RawState,

pub fn halted(Halt: Halt<Q>) -> Self

Creates a new instance of State from a Halt state.

pub fn unhalt(self) -> State<Q>

where Q: RawState,

Converts the halted state into an unhalted state.

Trait Implementations

impl<'a, A, B, C> Add<&'a State<B>> for &'a State<A>

where &'a A: RawState + Add<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the + operator.

fn add(self, rhs: &'a State<B>) -> Self::Output

Performs the + operation.

impl<'a, A, B, C> Add<&'a State<B>> for State<A>

where A: RawState + Add<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the + operator.

fn add(self, rhs: &'a State<B>) -> Self::Output

Performs the + operation.

impl<'a, A, B, C> Add<State<B>> for &'a State<A>

where &'a A: RawState + Add<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the + operator.

fn add(self, rhs: State<B>) -> Self::Output

Performs the + operation.

impl<A, B, C> Add<State<B>> for State<A>

where A: RawState + Add<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the + operator.

fn add(self, rhs: State<B>) -> Self::Output

Performs the + operation.

impl<A, B> AddAssign<B> for State<A>

where A: RawState + AddAssign<B>, B: RawState,

fn add_assign(&mut self, rhs: 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

Formats the value using the given formatter.

impl<'a, A, B, C> BitAnd<&'a State<B>> for &'a State<A>

where &'a A: RawState + BitAnd<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a State<B>) -> Self::Output

Performs the & operation.

impl<'a, A, B, C> BitAnd<&'a State<B>> for State<A>

where A: RawState + BitAnd<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a State<B>) -> Self::Output

Performs the & operation.

impl<'a, A, B, C> BitAnd<State<B>> for &'a State<A>

where &'a A: RawState + BitAnd<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the & operator.

fn bitand(self, rhs: State<B>) -> Self::Output

Performs the & operation.

impl<A, B, C> BitAnd<State<B>> for State<A>

where A: RawState + BitAnd<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the & operator.

fn bitand(self, rhs: State<B>) -> Self::Output

Performs the & operation.

impl<A, B> BitAndAssign<B> for State<A>

where A: RawState + BitAndAssign<B>, B: RawState,

fn bitand_assign(&mut self, rhs: B)

Performs the &= operation.

impl<'a, A, B, C> BitOr<&'a State<B>> for &'a State<A>

where &'a A: RawState + BitOr<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a State<B>) -> Self::Output

Performs the | operation.

impl<'a, A, B, C> BitOr<&'a State<B>> for State<A>

where A: RawState + BitOr<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a State<B>) -> Self::Output

Performs the | operation.

impl<'a, A, B, C> BitOr<State<B>> for &'a State<A>

where &'a A: RawState + BitOr<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the | operator.

fn bitor(self, rhs: State<B>) -> Self::Output

Performs the | operation.

impl<A, B, C> BitOr<State<B>> for State<A>

where A: RawState + BitOr<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the | operator.

fn bitor(self, rhs: State<B>) -> Self::Output

Performs the | operation.

impl<A, B> BitOrAssign<B> for State<A>

where A: RawState + BitOrAssign<B>, B: RawState,

fn bitor_assign(&mut self, rhs: B)

Performs the |= operation.

impl<'a, A, B, C> BitXor<&'a State<B>> for &'a State<A>

where &'a A: RawState + BitXor<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a State<B>) -> Self::Output

Performs the ^ operation.

impl<'a, A, B, C> BitXor<&'a State<B>> for State<A>

where A: RawState + BitXor<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a State<B>) -> Self::Output

Performs the ^ operation.

impl<'a, A, B, C> BitXor<State<B>> for &'a State<A>

where &'a A: RawState + BitXor<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: State<B>) -> Self::Output

Performs the ^ operation.

impl<A, B, C> BitXor<State<B>> for State<A>

where A: RawState + BitXor<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: State<B>) -> Self::Output

Performs the ^ operation.

impl<A, B> BitXorAssign<B> for State<A>

where A: RawState + BitXorAssign<B>, B: RawState,

fn bitxor_assign(&mut self, rhs: 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 + ?Sized> Clone for State<Q>

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

Formats the value using the given formatter.

impl<Q: Default + ?Sized> Default for State<Q>

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) -> &Self::Target

Dereferences the value.

impl<Q> DerefMut for State<Q>

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

Mutably dereferences the value.

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

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::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

Formats the value using the given formatter.

impl<'a, A, B, C> Div<&'a State<B>> for &'a State<A>

where &'a A: RawState + Div<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the / operator.

fn div(self, rhs: &'a State<B>) -> Self::Output

Performs the / operation.

impl<'a, A, B, C> Div<&'a State<B>> for State<A>

where A: RawState + Div<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the / operator.

fn div(self, rhs: &'a State<B>) -> Self::Output

Performs the / operation.

impl<'a, A, B, C> Div<State<B>> for &'a State<A>

where &'a A: RawState + Div<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the / operator.

fn div(self, rhs: State<B>) -> Self::Output

Performs the / operation.

impl<A, B, C> Div<State<B>> for State<A>

where A: RawState + Div<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the / operator.

fn div(self, rhs: State<B>) -> Self::Output

Performs the / operation.

impl<A, B> DivAssign<B> for State<A>

where A: RawState + DivAssign<B>, B: RawState,

fn div_assign(&mut self, rhs: B)

Performs the /= operation.

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

fn from(Halt: Halt<Q>) -> Self

Converts to this type from the input type.

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

fn from(state: Q) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<Q> Haltable<Q> for State<Halt<Q>>

type State = State<Q>

fn is_halted(&self) -> bool

impl<Q> Haltable<Q> for State<Option<Q>>

type State = State<Q>

fn is_halted(&self) -> bool

impl<Q: Hash + ?Sized> Hash for State<Q>

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

where Q: LowerExp,

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

Formats the value using the given formatter.

impl<Q> LowerHex for State<Q>

where Q: LowerHex,

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

Formats the value using the given formatter.

impl<'a, A, B, C> Mul<&'a State<B>> for &'a State<A>

where &'a A: RawState + Mul<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a State<B>) -> Self::Output

Performs the * operation.

impl<'a, A, B, C> Mul<&'a State<B>> for State<A>

where A: RawState + Mul<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a State<B>) -> Self::Output

Performs the * operation.

impl<'a, A, B, C> Mul<State<B>> for &'a State<A>

where &'a A: RawState + Mul<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the * operator.

fn mul(self, rhs: State<B>) -> Self::Output

Performs the * operation.

impl<A, B, C> Mul<State<B>> for State<A>

where A: RawState + Mul<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the * operator.

fn mul(self, rhs: State<B>) -> Self::Output

Performs the * operation.

impl<A, B> MulAssign<B> for State<A>

where A: RawState + MulAssign<B>, B: RawState,

fn mul_assign(&mut self, rhs: B)

Performs the *= operation.

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

where &'a Q: RawState + Neg,

type Output = State<<&'a Q as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

where &'a Q: RawState + Neg,

type Output = State<<&'a Q as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Q> Neg for State<Q>

where Q: RawState + Neg,

type Output = State<<Q as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

where &'a Q: RawState + Not,

type Output = State<<&'a Q as Not>::Output>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

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

where &'a Q: RawState + Not,

type Output = State<<&'a Q as Not>::Output>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<Q> Not for State<Q>

where Q: RawState + Not,

type Output = State<<Q as Not>::Output>

The resulting type after applying the ! operator.

fn not(self) -> Self::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<Self, Self::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

Formats the value using the given formatter.

impl<Q> One for State<Q>

where Q: RawState + PartialEq + One,

fn one() -> Self

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 + ?Sized> Ord for State<Q>

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 + ?Sized> PartialEq for State<Q>

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 + ?Sized> PartialOrd for State<Q>

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: RawState + Rem<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a State<B>) -> Self::Output

Performs the % operation.

impl<'a, A, B, C> Rem<&'a State<B>> for State<A>

where A: RawState + Rem<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a State<B>) -> Self::Output

Performs the % operation.

impl<'a, A, B, C> Rem<State<B>> for &'a State<A>

where &'a A: RawState + Rem<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the % operator.

fn rem(self, rhs: State<B>) -> Self::Output

Performs the % operation.

impl<A, B, C> Rem<State<B>> for State<A>

where A: RawState + Rem<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the % operator.

fn rem(self, rhs: State<B>) -> Self::Output

Performs the % operation.

impl<A, B> RemAssign<B> for State<A>

where A: RawState + RemAssign<B>, B: RawState,

fn rem_assign(&mut self, rhs: B)

Performs the %= operation.

impl<Q> Serialize for State<Q>

where Q: Serialize + ?Sized,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::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: RawState + Shl<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a State<B>) -> Self::Output

Performs the << operation.

impl<'a, A, B, C> Shl<&'a State<B>> for State<A>

where A: RawState + Shl<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a State<B>) -> Self::Output

Performs the << operation.

impl<'a, A, B, C> Shl<State<B>> for &'a State<A>

where &'a A: RawState + Shl<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the << operator.

fn shl(self, rhs: State<B>) -> Self::Output

Performs the << operation.

impl<A, B, C> Shl<State<B>> for State<A>

where A: RawState + Shl<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the << operator.

fn shl(self, rhs: State<B>) -> Self::Output

Performs the << operation.

impl<A, B> ShlAssign<B> for State<A>

where A: RawState + ShlAssign<B>, B: RawState,

fn shl_assign(&mut self, rhs: B)

Performs the <<= operation.

impl<'a, A, B, C> Shr<&'a State<B>> for &'a State<A>

where &'a A: RawState + Shr<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a State<B>) -> Self::Output

Performs the >> operation.

impl<'a, A, B, C> Shr<&'a State<B>> for State<A>

where A: RawState + Shr<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a State<B>) -> Self::Output

Performs the >> operation.

impl<'a, A, B, C> Shr<State<B>> for &'a State<A>

where &'a A: RawState + Shr<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the >> operator.

fn shr(self, rhs: State<B>) -> Self::Output

Performs the >> operation.

impl<A, B, C> Shr<State<B>> for State<A>

where A: RawState + Shr<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the >> operator.

fn shr(self, rhs: State<B>) -> Self::Output

Performs the >> operation.

impl<A, B> ShrAssign<B> for State<A>

where A: RawState + ShrAssign<B>, B: RawState,

fn shr_assign(&mut self, rhs: B)

Performs the >>= operation.

impl<Q> Stated for State<Q>

type Item = Q

fn get(self) -> Q

fn get_ref(&self) -> &Q

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

fn set(&mut self, inner: Q)

impl<'a, A, B, C> Sub<&'a State<B>> for &'a State<A>

where &'a A: RawState + Sub<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a State<B>) -> Self::Output

Performs the - operation.

impl<'a, A, B, C> Sub<&'a State<B>> for State<A>

where A: RawState + Sub<&'a B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a State<B>) -> Self::Output

Performs the - operation.

impl<'a, A, B, C> Sub<State<B>> for &'a State<A>

where &'a A: RawState + Sub<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the - operator.

fn sub(self, rhs: State<B>) -> Self::Output

Performs the - operation.

impl<A, B, C> Sub<State<B>> for State<A>

where A: RawState + Sub<B, Output = C>, B: RawState, C: RawState,

type Output = State<C>

The resulting type after applying the - operator.

fn sub(self, rhs: State<B>) -> Self::Output

Performs the - operation.

impl<A, B> SubAssign<B> for State<A>

where A: RawState + SubAssign<B>, B: RawState,

fn sub_assign(&mut self, rhs: B)

Performs the -= operation.

impl<Q> UpperExp for State<Q>

where Q: UpperExp,

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

Formats the value using the given formatter.

impl<Q> UpperHex for State<Q>

where Q: UpperHex,

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

Formats the value using the given formatter.

impl<Q> Zero for State<Q>

where Q: RawState + Zero,

fn zero() -> Self

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 + ?Sized> Copy for State<Q>

impl<Q: Eq + ?Sized> Eq for State<Q>

impl<Q> Send for State<Q>

where Q: Send,

impl<Q: ?Sized> StructuralPartialEq for State<Q>

impl<Q> Sync for State<Q>

where Q: Sync,