Enum memtable_core::exts::cell::Cell24

pub enum Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> {
    A(A),
    B(B),
    C(C),
    D(D),
    E(E),
    F(F),
    G(G),
    H(H),
    I(I),
    J(J),
    K(K),
    L(L),
    M(M),
    N(N),
    O(O),
    P(P),
    Q(Q),
    R(R),
    S(S),
    T(T),
    U(U),
    V(V),
    W(W),
    X(X),
}

This is supported on cell only.

Variants

A(A)

B(B)

C(C)

D(D)

E(E)

F(F)

G(G)

H(H)

I(I)

J(J)

K(K)

L(L)

M(M)

N(N)

O(O)

P(P)

Q(Q)

R(R)

S(S)

T(T)

U(U)

V(V)

W(W)

X(X)

Implementations

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

pub fn is_a(&self) -> bool

pub fn as_a(&self) -> Option<&A>

pub fn as_mut_a(&mut self) -> Option<&mut A>

pub fn into_a(self) -> Option<A>

pub fn is_b(&self) -> bool

pub fn as_b(&self) -> Option<&B>

pub fn as_mut_b(&mut self) -> Option<&mut B>

pub fn into_b(self) -> Option<B>

pub fn is_c(&self) -> bool

pub fn as_c(&self) -> Option<&C>

pub fn as_mut_c(&mut self) -> Option<&mut C>

pub fn into_c(self) -> Option<C>

pub fn is_d(&self) -> bool

pub fn as_d(&self) -> Option<&D>

pub fn as_mut_d(&mut self) -> Option<&mut D>

pub fn into_d(self) -> Option<D>

pub fn is_e(&self) -> bool

pub fn as_e(&self) -> Option<&E>

pub fn as_mut_e(&mut self) -> Option<&mut E>

pub fn into_e(self) -> Option<E>

pub fn is_f(&self) -> bool

pub fn as_f(&self) -> Option<&F>

pub fn as_mut_f(&mut self) -> Option<&mut F>

pub fn into_f(self) -> Option<F>

pub fn is_g(&self) -> bool

pub fn as_g(&self) -> Option<&G>

pub fn as_mut_g(&mut self) -> Option<&mut G>

pub fn into_g(self) -> Option<G>

pub fn is_h(&self) -> bool

pub fn as_h(&self) -> Option<&H>

pub fn as_mut_h(&mut self) -> Option<&mut H>

pub fn into_h(self) -> Option<H>

pub fn is_i(&self) -> bool

pub fn as_i(&self) -> Option<&I>

pub fn as_mut_i(&mut self) -> Option<&mut I>

pub fn into_i(self) -> Option<I>

pub fn is_j(&self) -> bool

pub fn as_j(&self) -> Option<&J>

pub fn as_mut_j(&mut self) -> Option<&mut J>

pub fn into_j(self) -> Option<J>

pub fn is_k(&self) -> bool

pub fn as_k(&self) -> Option<&K>

pub fn as_mut_k(&mut self) -> Option<&mut K>

pub fn into_k(self) -> Option<K>

pub fn is_l(&self) -> bool

pub fn as_l(&self) -> Option<&L>

pub fn as_mut_l(&mut self) -> Option<&mut L>

pub fn into_l(self) -> Option<L>

pub fn is_m(&self) -> bool

pub fn as_m(&self) -> Option<&M>

pub fn as_mut_m(&mut self) -> Option<&mut M>

pub fn into_m(self) -> Option<M>

pub fn is_n(&self) -> bool

pub fn as_n(&self) -> Option<&N>

pub fn as_mut_n(&mut self) -> Option<&mut N>

pub fn into_n(self) -> Option<N>

pub fn is_o(&self) -> bool

pub fn as_o(&self) -> Option<&O>

pub fn as_mut_o(&mut self) -> Option<&mut O>

pub fn into_o(self) -> Option<O>

pub fn is_p(&self) -> bool

pub fn as_p(&self) -> Option<&P>

pub fn as_mut_p(&mut self) -> Option<&mut P>

pub fn into_p(self) -> Option<P>

pub fn is_q(&self) -> bool

pub fn as_q(&self) -> Option<&Q>

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

pub fn into_q(self) -> Option<Q>

pub fn is_r(&self) -> bool

pub fn as_r(&self) -> Option<&R>

pub fn as_mut_r(&mut self) -> Option<&mut R>

pub fn into_r(self) -> Option<R>

pub fn is_s(&self) -> bool

pub fn as_s(&self) -> Option<&S>

pub fn as_mut_s(&mut self) -> Option<&mut S>

pub fn into_s(self) -> Option<S>

pub fn is_t(&self) -> bool

pub fn as_t(&self) -> Option<&T>

pub fn as_mut_t(&mut self) -> Option<&mut T>

pub fn into_t(self) -> Option<T>

pub fn is_u(&self) -> bool

pub fn as_u(&self) -> Option<&U>

pub fn as_mut_u(&mut self) -> Option<&mut U>

pub fn into_u(self) -> Option<U>

pub fn is_v(&self) -> bool

pub fn as_v(&self) -> Option<&V>

pub fn as_mut_v(&mut self) -> Option<&mut V>

pub fn into_v(self) -> Option<V>

pub fn is_w(&self) -> bool

pub fn as_w(&self) -> Option<&W>

pub fn as_mut_w(&mut self) -> Option<&mut W>

pub fn into_w(self) -> Option<W>

pub fn is_x(&self) -> bool

pub fn as_x(&self) -> Option<&X>

pub fn as_mut_x(&mut self) -> Option<&mut X>

pub fn into_x(self) -> Option<X>

Trait Implementations

impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone, L: Clone, M: Clone, N: Clone, O: Clone, P: Clone, Q: Clone, R: Clone, S: Clone, T: Clone, U: Clone, V: Clone, W: Clone, X: Clone> Clone for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

fn clone(
    &self
) -> Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug, C: Debug, D: Debug, E: Debug, F: Debug, G: Debug, H: Debug, I: Debug, J: Debug, K: Debug, L: Debug, M: Debug, N: Debug, O: Debug, P: Debug, Q: Debug, R: Debug, S: Debug, T: Debug, U: Debug, V: Debug, W: Debug, X: Debug> Debug for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

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

Formats the value using the given formatter.

impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Deserialize<'de> for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> where
    A: Deserialize<'de>,
    B: Deserialize<'de>,
    C: Deserialize<'de>,
    D: Deserialize<'de>,
    E: Deserialize<'de>,
    F: Deserialize<'de>,
    G: Deserialize<'de>,
    H: Deserialize<'de>,
    I: Deserialize<'de>,
    J: Deserialize<'de>,
    K: Deserialize<'de>,
    L: Deserialize<'de>,
    M: Deserialize<'de>,
    N: Deserialize<'de>,
    O: Deserialize<'de>,
    P: Deserialize<'de>,
    Q: Deserialize<'de>,
    R: Deserialize<'de>,
    S: Deserialize<'de>,
    T: Deserialize<'de>,
    U: Deserialize<'de>,
    V: Deserialize<'de>,
    W: Deserialize<'de>,
    X: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash, K: Hash, L: Hash, M: Hash, N: Hash, O: Hash, P: Hash, Q: Hash, R: Hash, S: Hash, T: Hash, U: Hash, V: Hash, W: Hash, X: Hash> Hash for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

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, 

Feeds a slice of this type into the given Hasher.

impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord, L: Ord, M: Ord, N: Ord, O: Ord, P: Ord, Q: Ord, R: Ord, S: Ord, T: Ord, U: Ord, V: Ord, W: Ord, X: Ord> Ord for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

fn cmp(
    &self,
    other: &Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>
) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K: PartialEq, L: PartialEq, M: PartialEq, N: PartialEq, O: PartialEq, P: PartialEq, Q: PartialEq, R: PartialEq, S: PartialEq, T: PartialEq, U: PartialEq, V: PartialEq, W: PartialEq, X: PartialEq> PartialEq<Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>> for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

fn eq(
    &self,
    other: &Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>
) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(
    &self,
    other: &Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>
) -> bool

This method tests for !=.

impl<A: PartialOrd, B: PartialOrd, C: PartialOrd, D: PartialOrd, E: PartialOrd, F: PartialOrd, G: PartialOrd, H: PartialOrd, I: PartialOrd, J: PartialOrd, K: PartialOrd, L: PartialOrd, M: PartialOrd, N: PartialOrd, O: PartialOrd, P: PartialOrd, Q: PartialOrd, R: PartialOrd, S: PartialOrd, T: PartialOrd, U: PartialOrd, V: PartialOrd, W: PartialOrd, X: PartialOrd> PartialOrd<Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>> for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

fn partial_cmp(
    &self,
    other: &Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>
) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Serialize for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> where
    A: Serialize,
    B: Serialize,
    C: Serialize,
    D: Serialize,
    E: Serialize,
    F: Serialize,
    G: Serialize,
    H: Serialize,
    I: Serialize,
    J: Serialize,
    K: Serialize,
    L: Serialize,
    M: Serialize,
    N: Serialize,
    O: Serialize,
    P: Serialize,
    Q: Serialize,
    R: Serialize,
    S: Serialize,
    T: Serialize,
    U: Serialize,
    V: Serialize,
    W: Serialize,
    X: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<A: Copy, B: Copy, C: Copy, D: Copy, E: Copy, F: Copy, G: Copy, H: Copy, I: Copy, J: Copy, K: Copy, L: Copy, M: Copy, N: Copy, O: Copy, P: Copy, Q: Copy, R: Copy, S: Copy, T: Copy, U: Copy, V: Copy, W: Copy, X: Copy> Copy for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq, M: Eq, N: Eq, O: Eq, P: Eq, Q: Eq, R: Eq, S: Eq, T: Eq, U: Eq, V: Eq, W: Eq, X: Eq> Eq for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> StructuralEq for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> StructuralPartialEq for Cell24<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X>