Trait AsBytes 

pub trait AsBytes<'a> {
    const SLICE_COUNT: usize;

    // Required method
    fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8]);

    // Provided method
    fn as_bytes(&self) -> impl Iterator<Item = (u64, &'a [u8])> { ... }
}

A type that can be viewed as byte slices with lifetime 'a.

Implementors of this trait almost certainly reference the lifetime 'a themselves.

Required Associated Constants

const SLICE_COUNT: usize

The number of byte slices this type produces.

Required Methods

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

Returns the index-th byte slice (alignment, data) by random access.

Each composite type dispatches on compile-time-constant SLICE_COUNT boundaries, so LLVM can constant-fold the branch chain when the caller iterates 0..SLICE_COUNT.

Provided Methods

fn as_bytes(&self) -> impl Iterator<Item = (u64, &'a [u8])>

Presents self as a sequence of byte slices, with their required alignment.

The default implementation iterates 0..SLICE_COUNT calling get_byte_slice. The return type is always Map<Range<usize>, ...> regardless of type complexity.

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl<'a, A: AsBytes<'a>, B: AsBytes<'a>, C: AsBytes<'a>, D: AsBytes<'a>, E: AsBytes<'a>, F: AsBytes<'a>, G: AsBytes<'a>, H: AsBytes<'a>, I: AsBytes<'a>, J: AsBytes<'a>> AsBytes<'a> for (A, B, C, D, E, F, G, H, I, J)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, A: AsBytes<'a>, B: AsBytes<'a>, C: AsBytes<'a>, D: AsBytes<'a>, E: AsBytes<'a>, F: AsBytes<'a>, G: AsBytes<'a>, H: AsBytes<'a>, I: AsBytes<'a>> AsBytes<'a> for (A, B, C, D, E, F, G, H, I)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, A: AsBytes<'a>, B: AsBytes<'a>, C: AsBytes<'a>, D: AsBytes<'a>, E: AsBytes<'a>, F: AsBytes<'a>, G: AsBytes<'a>, H: AsBytes<'a>> AsBytes<'a> for (A, B, C, D, E, F, G, H)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, A: AsBytes<'a>, B: AsBytes<'a>, C: AsBytes<'a>, D: AsBytes<'a>, E: AsBytes<'a>, F: AsBytes<'a>, G: AsBytes<'a>> AsBytes<'a> for (A, B, C, D, E, F, G)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, A: AsBytes<'a>, B: AsBytes<'a>, C: AsBytes<'a>, D: AsBytes<'a>, E: AsBytes<'a>, F: AsBytes<'a>> AsBytes<'a> for (A, B, C, D, E, F)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, A: AsBytes<'a>, B: AsBytes<'a>, C: AsBytes<'a>, D: AsBytes<'a>, E: AsBytes<'a>> AsBytes<'a> for (A, B, C, D, E)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, A: AsBytes<'a>, B: AsBytes<'a>, C: AsBytes<'a>, D: AsBytes<'a>> AsBytes<'a> for (A, B, C, D)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, A: AsBytes<'a>, B: AsBytes<'a>, C: AsBytes<'a>> AsBytes<'a> for (A, B, C)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, A: AsBytes<'a>, B: AsBytes<'a>> AsBytes<'a> for (A, B)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, A: AsBytes<'a>> AsBytes<'a> for (A,)

const SLICE_COUNT: usize

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, T: AsBytes<'a>> AsBytes<'a> for Arc<T>

const SLICE_COUNT: usize = T::SLICE_COUNT

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, T: AsBytes<'a>> AsBytes<'a> for Rc<T>

const SLICE_COUNT: usize = T::SLICE_COUNT

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[Wrapping<i8>; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[Wrapping<i16>; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[Wrapping<i32>; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[Wrapping<i64>; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[Wrapping<u8>; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[Wrapping<u16>; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[Wrapping<u32>; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[Wrapping<u64>; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[f32; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[f64; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[i8; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[i16; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[i32; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[i64; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[u8; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[u16; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[u32; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a, const N: usize> AsBytes<'a> for &'a [[u64; N]]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [Wrapping<i8>]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [Wrapping<i16>]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [Wrapping<i32>]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [Wrapping<i64>]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [Wrapping<u8>]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [Wrapping<u16>]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [Wrapping<u32>]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [Wrapping<u64>]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [f32]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [f64]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [i8]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [i16]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [i32]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [i64]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [u8]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [u16]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [u32]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

impl<'a> AsBytes<'a> for &'a [u64]

const SLICE_COUNT: usize = 1

fn get_byte_slice(&self, index: usize) -> (u64, &'a [u8])

Implementors

impl<'a, BC: AsBytes<'a>, VC: AsBytes<'a>> AsBytes<'a> for Strings<BC, VC>

const SLICE_COUNT: usize

impl<'a, BC: AsBytes<'a>> AsBytes<'a> for Strides<BC, &'a [u64]>

const SLICE_COUNT: usize

impl<'a, C: AsBytes<'a>> AsBytes<'a> for Boxed<C>

const SLICE_COUNT: usize = C::SLICE_COUNT

impl<'a, CC: AsBytes<'a>, VC: AsBytes<'a>> AsBytes<'a> for RankSelect<CC, VC, &'a [u64]>

const SLICE_COUNT: usize

impl<'a, CV: AsBytes<'a>> AsBytes<'a> for Chars<CV>

const SLICE_COUNT: usize = CV::SLICE_COUNT

impl<'a, CV: AsBytes<'a>> AsBytes<'a> for I128s<CV>

const SLICE_COUNT: usize = CV::SLICE_COUNT

impl<'a, CV: AsBytes<'a>> AsBytes<'a> for Isizes<CV>

const SLICE_COUNT: usize = CV::SLICE_COUNT

impl<'a, CV: AsBytes<'a>> AsBytes<'a> for U128s<CV>

const SLICE_COUNT: usize = CV::SLICE_COUNT

impl<'a, CV: AsBytes<'a>> AsBytes<'a> for Usizes<CV>

const SLICE_COUNT: usize = CV::SLICE_COUNT

impl<'a, CVar: AsBytes<'a>, COff: AsBytes<'a>> AsBytes<'a> for Discriminant<CVar, COff>

const SLICE_COUNT: usize

impl<'a, SC: AsBytes<'a>, NC: AsBytes<'a>> AsBytes<'a> for Durations<SC, NC>

const SLICE_COUNT: usize

impl<'a, SC: AsBytes<'a>, TC: AsBytes<'a>, CC: AsBytes<'a>, VC: AsBytes<'a>> AsBytes<'a> for Results<SC, TC, CC, VC, &'a [u64]>

const SLICE_COUNT: usize

impl<'a, TC: AsBytes<'a>, BC: AsBytes<'a>> AsBytes<'a> for Trees<TC, BC>

const SLICE_COUNT: usize

impl<'a, TC: AsBytes<'a>, BC: AsBytes<'a>> AsBytes<'a> for Vecs<TC, BC>

const SLICE_COUNT: usize

impl<'a, TC: AsBytes<'a>, CC: AsBytes<'a>, VC: AsBytes<'a>> AsBytes<'a> for Options<TC, CC, VC, &'a [u64]>

const SLICE_COUNT: usize

impl<'a, TC: AsBytes<'a>, CC: AsBytes<'a>, VC: AsBytes<'a>> AsBytes<'a> for Repeats<TC, CC, VC, &'a [u64]>

const SLICE_COUNT: usize

impl<'a, TC: AsBytes<'a>, VC: AsBytes<'a>, CC: AsBytes<'a>, RC: AsBytes<'a>> AsBytes<'a> for Lookbacks<TC, VC, CC, RC, &'a [u64]>

const SLICE_COUNT: usize

impl<'a, VC: AsBytes<'a>> AsBytes<'a> for Bools<VC, &'a [u64]>

const SLICE_COUNT: usize

impl<'a, const K: u64> AsBytes<'a> for Fixeds<K, &'a u64>

const SLICE_COUNT: usize = 1

impl<'a> AsBytes<'a> for Empties<&'a u64>

const SLICE_COUNT: usize = 1