Function pack_ints_sized

src/pack_ints.rs:350–389

[`pack_ints`] but after isize has been converted to i64.

(ints: &mut [T], out: &mut Vec<u8>)

/// [`pack_ints`] but after isize has been converted to i64.
fn pack_ints_sized<T: SizedInt>(ints: &mut [T], out: &mut Vec<u8>) {
    // Handle i8 right away since pack_bytes needs to know that it's signed.
    // If we didn't have this special case [0i8, -1, 0, -1, 0, -1] couldn't be packed.
    // Doesn't affect larger signed ints because they're made positive before pack_bytes::<u8> is called.
    if std::mem::size_of::<T>() == 1 && T::MIN < T::default() {
        let ints: &mut [i8] = bytemuck::must_cast_slice_mut(ints);
        pack_bytes(ints, out);
        return;
    };

    let (basic_packing, min_max) = if skip_packing::<T>(ints.len()) {
        (Packing::new(T::Unsigned::MAX), None)
    } else {
        // Take a small sample to avoid wastefully scanning the whole slice.
        let (sample, remaining) = ints.split_at(ints.len().min(16));
        let (min, max) = minmax(sample);

        // Only have to check packing(max - min) since it's always as good as packing(max).
        let none = Packing::new(T::Unsigned::MAX);
        if Packing::new(max.to_unsigned().wrapping_sub(min.to_unsigned())) == none {
            none.write::<T::Unsigned>(out, false);
            (none, None)
        } else {
            let (remaining_min, remaining_max) = minmax(remaining);
            let min = min.min(remaining_min);
            let max = max.max(remaining_max);

            // Signed ints pack as unsigned ints if positive.
            let basic_packing = if min >= T::default() {
                Packing::new(max.to_unsigned())
            } else {
                none // Any negative can't be packed without offset_packing.
            };
            (basic_packing, Some((min, max)))
        }
    };
    let ints = bytemuck::must_cast_slice_mut(ints);
    let min_max = min_max.map(|(min, max)| (min.to_unsigned(), max.to_unsigned()));
    pack_ints_sized_unsigned::<T::Unsigned>(ints, out, basic_packing, min_max);
}

/// [`pack_ints_sized`] but after signed integers have been cast to unsigned.
fn pack_ints_sized_unsigned<T: SizedUInt>(