Trait bv::BitSliceable

pub trait BitSliceable<Range>: Bits {
    type Slice: Bits<Block = Self::Block>;
    fn bit_slice(self, range: Range) -> Self::Slice;
}

Types that support slicing by ranges.

Note that the bit_slice method takes self by value, which allows the Slice associated type to refer to the lifetime of Self in impls for borrowed types. For example, the impl for &'a BitVec<u32> has a Slice type of BitSlice<'a, u32>.

Associated Types

type Slice: Bits<Block = Self::Block>

The type of the slice produced.

Required Methods

fn bit_slice(self, range: Range) -> Self::Slice

Slices or re-slices the given object.

Examples

use bv::{BitSlice, BitSliceable};

let array = [0b01010011u16];
let slice = BitSlice::from_slice(&array);

assert_eq!( slice.bit_slice(1..3), slice.bit_slice(4..6) );
assert_eq!( slice.bit_slice(1..3), slice.bit_slice(6..8) );

assert_ne!( slice.bit_slice(2..4), slice.bit_slice(6..8) );
assert_eq!( slice.bit_slice(2..4), slice.bit_slice(7..9) );

Implementations on Foreign Types

impl<'a> BitSliceable<RangeFull> for &'a [bool]

type Slice = &'a [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, _: RangeFull) -> &'a [bool]

impl<'a> BitSliceable<RangeFull> for &'a mut [bool]

type Slice = &'a mut [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, _: RangeFull) -> &'a mut [bool]

impl<'a> BitSliceable<Range<u64>> for &'a [bool]

type Slice = &'a [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: Range<u64>) -> &'a [bool]

impl<'a> BitSliceable<Range<u64>> for &'a mut [bool]

type Slice = &'a mut [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: Range<u64>) -> &'a mut [bool]

impl<'a> BitSliceable<RangeInclusive<u64>> for &'a [bool]

type Slice = &'a [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: RangeInclusive<u64>) -> &'a [bool]

impl<'a> BitSliceable<RangeInclusive<u64>> for &'a mut [bool]

type Slice = &'a mut [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: RangeInclusive<u64>) -> &'a mut [bool]

impl<'a> BitSliceable<RangeFrom<u64>> for &'a [bool]

type Slice = &'a [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: RangeFrom<u64>) -> &'a [bool]

impl<'a> BitSliceable<RangeFrom<u64>> for &'a mut [bool]

type Slice = &'a mut [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: RangeFrom<u64>) -> &'a mut [bool]

impl<'a> BitSliceable<RangeTo<u64>> for &'a [bool]

type Slice = &'a [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: RangeTo<u64>) -> &'a [bool]

impl<'a> BitSliceable<RangeTo<u64>> for &'a mut [bool]

type Slice = &'a mut [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: RangeTo<u64>) -> &'a mut [bool]

impl<'a> BitSliceable<RangeToInclusive<u64>> for &'a [bool]

type Slice = &'a [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: RangeToInclusive<u64>) -> &'a [bool]

impl<'a> BitSliceable<RangeToInclusive<u64>> for &'a mut [bool]

type Slice = &'a mut [bool]

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bit_slice(self, range: RangeToInclusive<u64>) -> &'a mut [bool]

impl<'a, Block, R> BitSliceable<R> for &'a [Block] where     Block: BlockType,     BitSlice<'a, Block>: BitSliceable<R, Block = Block, Slice = BitSlice<'a, Block>>,

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, Block, R> BitSliceable<R> for &'a mut [Block] where     Block: BlockType,     BitSliceMut<'a, Block>: BitSliceable<R, Block = Block, Slice = BitSliceMut<'a, Block>>,

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 0] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 0] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 1] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 1] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 2] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 2] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 3] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 3] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 4] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 4] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 5] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 5] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 6] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 6] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 7] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 7] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 8] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 8] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 9] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 9] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 10] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 10] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 11] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 11] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 12] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 12] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 13] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 13] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 14] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 14] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 15] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 15] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 16] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 16] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 17] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 17] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 18] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 18] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 19] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 19] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 20] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 20] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 21] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 21] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 22] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 22] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 23] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 23] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 24] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 24] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 25] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 25] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 26] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 26] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 27] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 27] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 28] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 28] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 29] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 29] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 30] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 30] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 31] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 31] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 32] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 32] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 64] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 64] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 128] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 128] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 256] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 256] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 512] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 512] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 1024] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 1024] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 2048] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 2048] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 4096] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 4096] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 8192] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 8192] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 16384] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 16384] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 32768] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 32768] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 65536] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 65536] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 131072] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 131072] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 262144] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 262144] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 524288] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 524288] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 1048576] where     &'a [Block]: BitSliceable<R, Block = Block>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 1048576] where     &'a [bool]: BitSliceable<R, Block = u8>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

Implementors

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<T: Bits> BitSliceable<Range<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeTo<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeFrom<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeFull> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeInclusive<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeToInclusive<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<'a, T: Bits> BitSliceable<Range<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeTo<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeFrom<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeFull> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeInclusive<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeToInclusive<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<R, T> BitSliceable<R> for BitNot<T> where     T: BitSliceable<R>,  type Slice = BitNot<T::Slice>;

• impl<'a, T: Bits> BitSliceable<Range<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeFrom<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeTo<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeFull> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeInclusive<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeToInclusive<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<Block, R, T, U> BitSliceable<R> for BitAnd<T, U> where     Block: BlockType,     R: Clone,     T: BitSliceable<R, Block = Block>,     U: BitSliceable<R, Block = Block>,  type Slice = BitAnd<T::Slice, U::Slice>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<Block, R, T, U> BitSliceable<R> for BitOr<T, U> where     Block: BlockType,     R: Clone,     T: BitSliceable<R, Block = Block>,     U: BitSliceable<R, Block = Block>,  type Slice = BitOr<T::Slice, U::Slice>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<Block, R, T, U> BitSliceable<R> for BitXor<T, U> where     Block: BlockType,     R: Clone,     T: BitSliceable<R, Block = Block>,     U: BitSliceable<R, Block = Block>,  type Slice = BitXor<T::Slice, U::Slice>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<Block, R, T, U, F> BitSliceable<R> for BitZip<T, U, F> where     Block: BlockType,     R: Clone,     T: BitSliceable<R, Block = Block>,     U: BitSliceable<R, Block = Block>,     F: Fn(Block, Block) -> Block,  type Slice = BitZip<T::Slice, U::Slice, F>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<Range<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeFrom<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeTo<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeFull> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeInclusive<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeToInclusive<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<Range<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeFrom<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeTo<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeFull> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeInclusive<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeToInclusive<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;