Function serialize_value

crates/table/src/bflatn_from.rs:234–313

Serialize `value = &bytes[range_move(0..ty.size(), *curr_offset)]` into a `ser`, using `blob_store` to retrieve the bytes of any large blob object and `curr_offset`, advanced as serialization progresses, to decide where to start reading. SAFETY: 1. the `value` must be valid at type `ty` and properly aligned for `ty`. 2. for any `vlr: VarLenRef` stored in `value`, `vlr.first_offset` must either be

(
    ser: S,
    bytes: &Bytes,
    page: &Page,
    blob_store: &dyn BlobStore,
    curr_offset: CurrOffset<'_>,
    ty: &AlgebraicTypeLayout,
)

///    `vlr.first_offset` must either be `NULL` or point to a valid granule in `page`.
/// 3. `align_to(curr_offset.get(), ty.align())` must be the offset of a field typed at `ty`.
pub(crate) unsafe fn serialize_value<S: Serializer>(
    ser: S,
    bytes: &Bytes,
    page: &Page,
    blob_store: &dyn BlobStore,
    curr_offset: CurrOffset<'_>,
    ty: &AlgebraicTypeLayout,
) -> Result<S::Ok, S::Error> {
    debug_assert_eq!(
        curr_offset.get(),
        align_to(curr_offset.get(), ty.align()),
        "curr_offset {curr_offset:?} insufficiently aligned for type {ty:#?}",
    );

    match ty {
        AlgebraicTypeLayout::Sum(ty) => {
            // SAFETY: `value` was valid at `ty` and `VarLenRef`s won't be dangling.
            unsafe { serialize_sum(ser, bytes, page, blob_store, curr_offset, ty) }
        }
        AlgebraicTypeLayout::Product(ty) => {
            // SAFETY: `value` was valid at `ty` and `VarLenRef`s won't be dangling.
            unsafe { serialize_product(ser, bytes, page, blob_store, curr_offset, ty.view()) }
        }
        // The primitive types:
        //
        // SAFETY (applies to app primitive types):
        // Per caller requirement, know `value` points to a valid `ty`.
        // Thus `&bytes[range_move(0..ty.size(), *curr_offset)]` points to init bytes
        // and `ty.size()` corresponds exactly to `N = 1, 1, 1, 2, 2, 4, 4, 8, 8, 16, 16, 32, 32, 4, 8`.
        &AlgebraicTypeLayout::Bool => ser.serialize_bool(unsafe { read_from_bytes::<u8>(bytes, curr_offset) } != 0),
        &AlgebraicTypeLayout::I8 => ser.serialize_i8(unsafe { read_from_bytes(bytes, curr_offset) }),
        &AlgebraicTypeLayout::U8 => ser.serialize_u8(unsafe { read_from_bytes(bytes, curr_offset) }),
        &AlgebraicTypeLayout::I16 => {
            ser.serialize_i16(i16::from_le_bytes(unsafe { read_from_bytes(bytes, curr_offset) }))
        }
        &AlgebraicTypeLayout::U16 => {
            ser.serialize_u16(u16::from_le_bytes(unsafe { read_from_bytes(bytes, curr_offset) }))
        }
        &AlgebraicTypeLayout::I32 => {
            ser.serialize_i32(i32::from_le_bytes(unsafe { read_from_bytes(bytes, curr_offset) }))
        }
        &AlgebraicTypeLayout::U32 => {
            ser.serialize_u32(u32::from_le_bytes(unsafe { read_from_bytes(bytes, curr_offset) }))
        }
        &AlgebraicTypeLayout::I64 => {
            ser.serialize_i64(i64::from_le_bytes(unsafe { read_from_bytes(bytes, curr_offset) }))
        }
        &AlgebraicTypeLayout::U64 => {
            ser.serialize_u64(u64::from_le_bytes(unsafe { read_from_bytes(bytes, curr_offset) }))
        }
        &AlgebraicTypeLayout::I128 => {
            ser.serialize_i128(i128::from_le_bytes(unsafe { read_from_bytes(bytes, curr_offset) }))
        }
        &AlgebraicTypeLayout::U128 => {
            ser.serialize_u128(u128::from_le_bytes(unsafe { read_from_bytes(bytes, curr_offset) }))
        }
        &AlgebraicTypeLayout::I256 => {
            ser.serialize_i256(i256::from_le_bytes(unsafe { read_from_bytes(bytes, curr_offset) }))