Method process_from_bytes_key

crates/table/src/table_index/bytes_key.rs:502–538

(mut slice: &'a mut [u8], ty: &AlgebraicType)

    }

    fn process_from_bytes_key<'a>(mut slice: &'a mut [u8], ty: &AlgebraicType) -> &'a mut [u8] {
        use AlgebraicType::*;
        match ty {
            // For sums, read the tag and process the active variant.
            Sum(ty) => {
                let (&mut tag, rest) = slice.split_first_mut().unwrap();
                let ty = &ty.variants[tag as usize].algebraic_type;
                Self::process_from_bytes_key(rest, ty)
            }
            // For products, just process each field in sequence.
            Product(ty) => {
                for ty in &ty.elements {
                    slice = Self::process_from_bytes_key(slice, &ty.algebraic_type);
                }
                slice
            }
            // No need to do anything as these are only a single byte long.
            Bool | U8 => &mut slice[1..],
            // For unsigned integers, read them as LE and write back as BE.
            U16 => split_map_write_back(slice, |b| u16::from_le_bytes(b).to_be_bytes()),
            U32 => split_map_write_back(slice, |b| u32::from_le_bytes(b).to_be_bytes()),
            U64 => split_map_write_back(slice, |b| u64::from_le_bytes(b).to_be_bytes()),
            U128 => split_map_write_back(slice, |b| u128::from_le_bytes(b).to_be_bytes()),
            U256 => split_map_write_back(slice, |b| u256::from_le_bytes(b).to_be_bytes()),
            // For signed integers, read them as LE, make them unsigned, and write back as BE.
            I8 => split_map_write_back(slice, |b| i8::from_le_bytes(b).wrapping_sub(i8::MIN).to_be_bytes()),
            I16 => split_map_write_back(slice, |b| i16::from_le_bytes(b).wrapping_sub(i16::MIN).to_be_bytes()),
            I32 => split_map_write_back(slice, |b| i32::from_le_bytes(b).wrapping_sub(i32::MIN).to_be_bytes()),
            I64 => split_map_write_back(slice, |b| i64::from_le_bytes(b).wrapping_sub(i64::MIN).to_be_bytes()),
            I128 => split_map_write_back(slice, |b| i128::from_le_bytes(b).wrapping_sub(i128::MIN).to_be_bytes()),
            I256 => split_map_write_back(slice, |b| i256::from_le_bytes(b).wrapping_sub(i256::MIN).to_be_bytes()),
            // Refs don't exist here and
            // arrays and strings are of unbounded length.
            // For floats, we haven't considred them yet.
            Ref(_) | Array(_) | String | F32 | F64 => unreachable!(),
        }
    }

    fn to_bytes_key(key: Self, ty: &AlgebraicType) -> BytesKey<N> {
        fn process<'a>(mut slice: &'a mut [u8], ty: &AlgebraicType) -> &'a mut [u8] {