Function decode

nodedb-codec/src/alp.rs:154–246

Decode ALP-compressed bytes back to f64 values.

(data: &[u8])

/// Decode ALP-compressed bytes back to f64 values.
pub fn decode(data: &[u8]) -> Result<Vec<f64>, CodecError> {
    const HEADER_SIZE: usize = 11; // 4 + 1 + 1 + 1 + 4

    if data.len() < HEADER_SIZE {
        return Err(CodecError::Truncated {
            expected: HEADER_SIZE,
            actual: data.len(),
        });
    }

    let count = u32::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize;
    let _encode_exp = data[4];
    let decode_exp = data[5];
    let mode = match data[6] {
        0 => DecodeMode::MultiplyInverse,
        1 => DecodeMode::DivideByFactor,
        m => {
            return Err(CodecError::Corrupt {
                detail: format!("invalid ALP decode mode {m}"),
            });
        }
    };
    let exception_count = u32::from_le_bytes([data[7], data[8], data[9], data[10]]) as usize;

    if count == 0 {
        return Ok(Vec::new());
    }

    if decode_exp > MAX_EXPONENT {
        return Err(CodecError::Corrupt {
            detail: format!("invalid ALP decode_exp {decode_exp}"),
        });
    }

    // Read exceptions.
    let exceptions_size = exception_count * 12;
    let exceptions_end = HEADER_SIZE + exceptions_size;
    if data.len() < exceptions_end {
        return Err(CodecError::Truncated {
            expected: exceptions_end,
            actual: data.len(),
        });
    }

    let mut exceptions = Vec::with_capacity(exception_count);
    let mut pos = HEADER_SIZE;
    for _ in 0..exception_count {
        let idx =
            u32::from_le_bytes([data[pos], data[pos + 1], data[pos + 2], data[pos + 3]]) as usize;
        let bits = u64::from_le_bytes([
            data[pos + 4],
            data[pos + 5],
            data[pos + 6],
            data[pos + 7],
            data[pos + 8],
            data[pos + 9],
            data[pos + 10],
            data[pos + 11],