Trait bit_manager::data::BitStore

pub trait BitStore: Sized {
    fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>;
    fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>;
}

A trait for storing a value directly

Derive

BitStore can be derived using the bit manager derive crate.

Storage Primitives

• bool, u8 (directly implemented)
• u16, u32, u64
• i8, i16, i32, i64
• f32, f64
• String (through StringConverter)
• Option<T> where T can be stored
• Result<T, F> where T and F can be stored
• [T; 0] through [T; 32] where T can be stored
• () (the unit type) and all tuples with 2 through 26 storable values

Required Methods

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

Reads a value from the given reader.

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

Writes this value to the given writer.

Implementations on Foreign Types

impl BitStore for bool

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for u8

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for i8

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for u16

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for i16

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for u32

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for i32

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for u64

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for i64

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for f32

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for f64

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for String

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for Option<T>

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore, F: BitStore> BitStore for Result<T, F>

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T> BitStore for [T; 0]

fn read_from<R: BitRead>(_: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, _: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 1]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 2]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 3]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 4]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 5]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 6]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 7]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 8]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 9]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 10]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 11]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 12]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 13]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 14]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 15]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 16]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 17]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 18]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 19]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 20]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 21]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 22]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 23]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 24]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 25]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 26]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 27]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 28]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 29]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 30]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 31]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl<T: BitStore> BitStore for [T; 32]

fn read_from<R: BitRead>(reader: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, writer: &mut W) -> Result<()>

impl BitStore for ()

fn read_from<R: BitRead>(_: &mut R) -> Result<Self>

fn write_to<W: BitWrite>(&self, _: &mut W) -> Result<()>

impl<A, B> BitStore for (A, B) where
    A: BitStore,
    B: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C> BitStore for (A, B, C) where
    A: BitStore,
    B: BitStore,
    C: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D> BitStore for (A, B, C, D) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E> BitStore for (A, B, C, D, E) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F> BitStore for (A, B, C, D, E, F) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G> BitStore for (A, B, C, D, E, F, G) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H> BitStore for (A, B, C, D, E, F, G, H) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I> BitStore for (A, B, C, D, E, F, G, H, I) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J> BitStore for (A, B, C, D, E, F, G, H, I, J) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K> BitStore for (A, B, C, D, E, F, G, H, I, J, K) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore,
    P: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore,
    P: BitStore,
    Q: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore,
    P: BitStore,
    Q: BitStore,
    R: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore,
    P: BitStore,
    Q: BitStore,
    R: BitStore,
    S: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore,
    P: BitStore,
    Q: BitStore,
    R: BitStore,
    S: BitStore,
    T: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore,
    P: BitStore,
    Q: BitStore,
    R: BitStore,
    S: BitStore,
    T: BitStore,
    U: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

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

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

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

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

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> BitStore for (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: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore,
    P: BitStore,
    Q: BitStore,
    R: BitStore,
    S: BitStore,
    T: BitStore,
    U: BitStore,
    V: BitStore,
    W: BitStore,
    X: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

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, Y> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore,
    P: BitStore,
    Q: BitStore,
    R: BitStore,
    S: BitStore,
    T: BitStore,
    U: BitStore,
    V: BitStore,
    W: BitStore,
    X: BitStore,
    Y: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

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, Y, Z> BitStore for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    A: BitStore,
    B: BitStore,
    C: BitStore,
    D: BitStore,
    E: BitStore,
    F: BitStore,
    G: BitStore,
    H: BitStore,
    I: BitStore,
    J: BitStore,
    K: BitStore,
    L: BitStore,
    M: BitStore,
    N: BitStore,
    O: BitStore,
    P: BitStore,
    Q: BitStore,
    R: BitStore,
    S: BitStore,
    T: BitStore,
    U: BitStore,
    V: BitStore,
    W: BitStore,
    X: BitStore,
    Y: BitStore,
    Z: BitStore, 

fn read_from<READ: BitRead>(reader: &mut READ) -> Result<Self>

fn write_to<WRITE: BitWrite>(&self, writer: &mut WRITE) -> Result<()>

Implementors

• impl BitStore for StringConverter
• impl BitStore for BitMask
• impl BitStore for DefaultConverter