Trait Packable

pub trait Packable {
    // Required method
    fn pack<T>(&self, buf: &mut T) -> usize
       where T: Extend<u8>;

    // Provided method
    fn pack_to_vec(&self) -> Vec<u8>  { ... }
}

A packable type.

Required Methods

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

Pack a value into the extendable buffer, returning the amount of written bytes.

Provided Methods

fn pack_to_vec(&self) -> Vec<u8>

Packs the value into a vector of bytes.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Packable for bool

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for f32

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for f64

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for i8

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for i16

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for i32

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for i64

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for i128

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for isize

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for str

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for u8

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for u16

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for u32

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for u64

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for u128

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for ()

fn pack<T>(&self, _buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for usize

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for String

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for Vec<u8>

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl Packable for [u8]

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<A> Packable for (A,)

where A: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

impl<A, B> Packable for (A, B)

where A: Packable, B: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

impl<A, B, C> Packable for (A, B, C)

where A: Packable, B: Packable, C: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

impl<A, B, C, D> Packable for (A, B, C, D)

where A: Packable, B: Packable, C: Packable, D: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

impl<A, B, C, D, E> Packable for (A, B, C, D, E)

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

impl<A, B, C, D, E, F> Packable for (A, B, C, D, E, F)

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

impl<A, B, C, D, E, F, G> Packable for (A, B, C, D, E, F, G)

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

impl<A, B, C, D, E, F, G, H> Packable for (A, B, C, D, E, F, G, H)

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable, N: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable, N: Packable, O: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable, N: Packable, O: Packable, P: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable, N: Packable, O: Packable, P: Packable, Q: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable, N: Packable, O: Packable, P: Packable, Q: Packable, R: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable, N: Packable, O: Packable, P: Packable, Q: Packable, R: Packable, S: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable, N: Packable, O: Packable, P: Packable, Q: Packable, R: Packable, S: Packable, T: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

where A: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable, N: Packable, O: Packable, P: Packable, Q: Packable, R: Packable, S: Packable, T: Packable, U: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Packable 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: Packable, B: Packable, C: Packable, D: Packable, E: Packable, F: Packable, G: Packable, H: Packable, I: Packable, J: Packable, K: Packable, L: Packable, M: Packable, N: Packable, O: Packable, P: Packable, Q: Packable, R: Packable, S: Packable, T: Packable, U: Packable, V: Packable,

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

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

fn pack<TT>(&self, buf: &mut TT) -> usize

where TT: Extend<u8>,

impl<K, V> Packable for BTreeMap<K, V>

where K: Packable, V: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<K, V> Packable for HashMap<K, V>

where K: Packable, V: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for Option<X>

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 0]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 1]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 2]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 3]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 4]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 5]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 6]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 7]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 8]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 9]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 10]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 11]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 12]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 13]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 14]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 15]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 16]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 17]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 18]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 19]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 20]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 21]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 22]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 23]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 24]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 25]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 26]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 27]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 28]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 29]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 30]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 31]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 32]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 33]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 34]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 35]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 36]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 37]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 38]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 39]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 40]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 41]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 42]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 43]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 44]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 45]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 46]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 47]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 48]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 49]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 50]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 51]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 52]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 53]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 54]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 55]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 56]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 57]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 58]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 59]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 60]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 61]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 62]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 63]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for [X; 64]

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for &X

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for &mut X

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for BinaryHeap<X>

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for BTreeSet<X>

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for LinkedList<X>

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for VecDeque<X>

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for PhantomData<X>

fn pack<T>(&self, _buf: &mut T) -> usize

where T: Extend<u8>,

impl<X> Packable for HashSet<X>

where X: Packable,

fn pack<T>(&self, buf: &mut T) -> usize

where T: Extend<u8>,

Implementors

impl Packable for Extension