Trait TuplePack

Source
pub trait TuplePack {
    // Required method
    fn pack<W>(
        &self,
        w: &mut W,
        tuple_depth: TupleDepth,
    ) -> Result<VersionstampOffset, Error>
       where W: Write;

    // Provided methods
    fn pack_root<W>(&self, w: &mut W) -> Result<VersionstampOffset, Error>
       where W: Write { ... }
    fn pack_to_vec(&self) -> Vec<u8> ⓘ { ... }
    fn pack_to_vec_with_versionstamp(&self) -> Vec<u8> ⓘ { ... }
    fn pack_into_vec(&self, output: &mut Vec<u8>) -> VersionstampOffset { ... }
    fn pack_into_vec_with_versionstamp(
        &self,
        output: &mut Vec<u8>,
    ) -> VersionstampOffset { ... }
}
Expand description

A type that can be packed

Required Methods§

Source

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Provided Methods§

Source

fn pack_root<W>(&self, w: &mut W) -> Result<VersionstampOffset, Error>
where W: Write,

Source

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

Pack value and returns the packed buffer

§Panics

Panics if the encoded data size doesn’t fit in u32.

Source

fn pack_to_vec_with_versionstamp(&self) -> Vec<u8> ⓘ

Pack a value with a four-byte versionstamp offset for API 520 and later. For keys under an earlier runtime API, use pack_with_versionstamp_for_key.

§Panics

Panics if there is multiple versionstamp present or if the encoded data size doesn’t fit in u32.

Source

fn pack_into_vec(&self, output: &mut Vec<u8>) -> VersionstampOffset

Pack value into the given buffer

§Panics

Panics if the encoded data size doesn’t fit in u32.

Source

fn pack_into_vec_with_versionstamp( &self, output: &mut Vec<u8>, ) -> VersionstampOffset

Pack a value into the buffer with a four-byte versionstamp offset for API 520 and later. For legacy keys, use pack_with_versionstamp_for_key or Subspace::pack_with_versionstamp_for_key with the buffer as a prefix.

§Panics

Panics if the encoded data size doesn’t fit in u32.

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§

Source§

impl TuplePack for &str

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for &[u8]

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for Cow<'_, str>

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for bool

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for f32

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for f64

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for i16

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for i32

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for i64

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for i128

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for isize

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for u16

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for u32

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for u64

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for u128

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for ()

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for usize

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for String

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for Vec<u8>

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for BigInt

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl TuplePack for BigUint

Source§

fn pack<W>( &self, w: &mut W, _tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0> TuplePack for (T0,)
where T0: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1> TuplePack for (T0, T1)
where T0: TuplePack, T1: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2> TuplePack for (T0, T1, T2)
where T0: TuplePack, T1: TuplePack, T2: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2, T3> TuplePack for (T0, T1, T2, T3)
where T0: TuplePack, T1: TuplePack, T2: TuplePack, T3: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2, T3, T4> TuplePack for (T0, T1, T2, T3, T4)
where T0: TuplePack, T1: TuplePack, T2: TuplePack, T3: TuplePack, T4: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2, T3, T4, T5> TuplePack for (T0, T1, T2, T3, T4, T5)
where T0: TuplePack, T1: TuplePack, T2: TuplePack, T3: TuplePack, T4: TuplePack, T5: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2, T3, T4, T5, T6> TuplePack for (T0, T1, T2, T3, T4, T5, T6)
where T0: TuplePack, T1: TuplePack, T2: TuplePack, T3: TuplePack, T4: TuplePack, T5: TuplePack, T6: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7> TuplePack for (T0, T1, T2, T3, T4, T5, T6, T7)
where T0: TuplePack, T1: TuplePack, T2: TuplePack, T3: TuplePack, T4: TuplePack, T5: TuplePack, T6: TuplePack, T7: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> TuplePack for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where T0: TuplePack, T1: TuplePack, T2: TuplePack, T3: TuplePack, T4: TuplePack, T5: TuplePack, T6: TuplePack, T7: TuplePack, T8: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TuplePack for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where T0: TuplePack, T1: TuplePack, T2: TuplePack, T3: TuplePack, T4: TuplePack, T5: TuplePack, T6: TuplePack, T7: TuplePack, T8: TuplePack, T9: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> TuplePack for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
where T0: TuplePack, T1: TuplePack, T2: TuplePack, T3: TuplePack, T4: TuplePack, T5: TuplePack, T6: TuplePack, T7: TuplePack, T8: TuplePack, T9: TuplePack, T10: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> TuplePack for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
where T0: TuplePack, T1: TuplePack, T2: TuplePack, T3: TuplePack, T4: TuplePack, T5: TuplePack, T6: TuplePack, T7: TuplePack, T8: TuplePack, T9: TuplePack, T10: TuplePack, T11: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T> TuplePack for &[T]
where T: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T> TuplePack for Option<T>
where T: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T> TuplePack for &T
where T: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Source§

impl<T> TuplePack for Vec<T>
where T: TuplePack,

Source§

fn pack<W>( &self, w: &mut W, tuple_depth: TupleDepth, ) -> Result<VersionstampOffset, Error>
where W: Write,

Implementors§