Function decode

nodedb-codec/src/alp_rd.rs:123–224

Decode ALP-RD compressed data back to f64 values.

(data: &[u8])

/// Decode ALP-RD compressed data back to f64 values.
pub fn decode(data: &[u8]) -> Result<Vec<f64>, CodecError> {
    if data.len() < 7 {
        return Err(CodecError::Truncated {
            expected: 7,
            actual: data.len(),
        });
    }

    let count = u32::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize;
    let cut = data[4];
    let dict_size = u16::from_le_bytes([data[5], data[6]]) as usize;

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

    if cut > 64 {
        return Err(CodecError::Corrupt {
            detail: format!("invalid ALP-RD cut position: {cut}"),
        });
    }

    let tail_bytes_per_value = (cut as usize).div_ceil(8);
    let tail_mask: u64 = if cut == 0 { 0 } else { (1u64 << cut) - 1 };
    let use_u8_indices = dict_size <= 256;

    // Read dictionary.
    let mut pos = 7;
    let dict_bytes = dict_size * 8;
    if pos + dict_bytes > data.len() {
        return Err(CodecError::Truncated {
            expected: pos + dict_bytes,
            actual: data.len(),
        });
    }
    let mut dict = Vec::with_capacity(dict_size);
    for _ in 0..dict_size {
        dict.push(u64::from_le_bytes([
            data[pos],
            data[pos + 1],
            data[pos + 2],
            data[pos + 3],
            data[pos + 4],
            data[pos + 5],
            data[pos + 6],
            data[pos + 7],
        ]));
        pos += 8;
    }

    // Read indices.
    let index_bytes = count * if use_u8_indices { 1 } else { 2 };
    if pos + index_bytes > data.len() {
        return Err(CodecError::Truncated {
            expected: pos + index_bytes,
            actual: data.len(),
        });
    }