Trait BitStore 

pub trait BitStore: Sized {
    // Required methods
    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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl BitStore for ()

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

fn write_to<W: BitWrite>(&self, _: &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 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 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 i8

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 i32

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 u8

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 u32

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

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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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<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> 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> 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<T> BitStore for [T; 0]

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

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

Implementors

impl BitStore for BitMask

impl BitStore for DefaultConverter

impl BitStore for StringConverter