core/test/rust/performance/bytes/mod.rs

fn byte_fault() -> Fault {
    &FaultInfo {
        message: "byte conversion failed",
        source: "reference.dever",
        line: 1,
        column: 1,
    }
}

fn total_reference(values: &dever_runtime::Bytes) -> Result<i64, Fault> {
    values.iter().try_fold(0i64, |total, value| {
        total.checked_add(i64::from(*value)).ok_or_else(byte_fault)
    })
}

fn each_reference(values: &dever_runtime::Bytes) -> Result<Vec<i64>, Fault> {
    values
        .iter()
        .map(|value| i64::from(*value).checked_add(1).ok_or_else(byte_fault))
        .collect()
}

fn encode_generated(values: &[String]) -> Result<dever_runtime::Bytes, Fault> {
    GENERATED_ENCODE(values.first().map(String::as_str).unwrap_or(""))
}

fn encode_reference(values: &[String]) -> Result<dever_runtime::Bytes, Fault> {
    Ok(values
        .first()
        .map(String::as_str)
        .unwrap_or("")
        .as_bytes()
        .to_vec()
        .into())
}

fn decode_generated(values: &dever_runtime::Bytes) -> Result<String, Fault> {
    GENERATED_DECODE(values).map_err(|_| byte_fault())
}

fn decode_reference(values: &dever_runtime::Bytes) -> Result<String, Fault> {
    std::str::from_utf8(values)
        .map(str::to_owned)
        .map_err(|_| byte_fault())
}

fn convert_generated(values: &[i64]) -> Result<dever_runtime::Bytes, Fault> {
    GENERATED_CONVERT(values).map_err(|_| byte_fault())
}

fn convert_reference(values: &[i64]) -> Result<dever_runtime::Bytes, Fault> {
    values
        .iter()
        .map(|value| u8::try_from(*value).map_err(|_| byte_fault()))
        .collect::<Result<Vec<_>, _>>()
        .map(Into::into)
}

fn slice_generated(values: &dever_runtime::Bytes) -> Result<dever_runtime::Bytes, Fault> {
    GENERATED_SLICE(values).map_err(|_| byte_fault())
}

fn slice_reference(values: &dever_runtime::Bytes) -> Result<dever_runtime::Bytes, Fault> {
    values
        .get(0..values.len())
        .map(<[u8]>::to_vec)
        .map(Into::into)
        .ok_or_else(byte_fault)
}

fn join_reference(values: &dever_runtime::Bytes) -> Result<dever_runtime::Bytes, Fault> {
    let mut result = Vec::with_capacity(values.len() + values.len());
    result.extend_from_slice(values);
    result.extend_from_slice(values);
    Ok(result.into())
}

fn roundtrip_generated(values: &[String]) -> Result<String, Fault> {
    GENERATED_ROUNDTRIP(values.first().map(String::as_str).unwrap_or("")).map_err(|_| byte_fault())
}

fn roundtrip_reference(values: &[String]) -> Result<String, Fault> {
    let bytes = values
        .first()
        .map(String::as_str)
        .unwrap_or("")
        .as_bytes()
        .to_vec();
    String::from_utf8(bytes).map_err(|_| byte_fault())
}

fn main() {
    let text = "hello 雪🙂 ".repeat(256);
    let texts = [text];
    let bytes = dever_runtime::Bytes::copy_from_slice(texts[0].as_bytes());
    let integers: Vec<i64> = (0..1024).map(|value| value % 256).collect();
    let invalid = dever_runtime::Bytes::from_static(&[255]);
    assert!(decode_generated(&invalid).is_err());
    assert!(decode_reference(&invalid).is_err());
    assert_eq!(GENERATED_IDENTITY(&bytes).unwrap().as_ptr(), bytes.as_ptr());
    assert!(convert_generated(&[-1]).is_err());
    assert!(convert_reference(&[-1]).is_err());
    assert!(convert_generated(&[256]).is_err());
    assert!(convert_reference(&[256]).is_err());
    println!("case,sample,implementation,elapsed_ns,checksum");
    compare_bytes(
        "bytes_reduce",
        &bytes,
        2000,
        GENERATED_TOTAL,
        total_reference,
        |value| *value as u64,
    );
    compare_bytes(
        "bytes_each",
        &bytes,
        2000,
        GENERATED_EACH,
        each_reference,
        |value| value.len() as u64,
    );
    compare(
        "bytes_encode",
        &texts,
        20000,
        encode_generated,
        encode_reference,
        |value| value.len() as u64,
    );
    compare_bytes(
        "bytes_decode",
        &bytes,
        4000,
        decode_generated,
        decode_reference,
        |value| value.len() as u64,
    );
    compare(
        "bytes_from_ints",
        &integers,
        2000,
        convert_generated,
        convert_reference,
        |value| value.len() as u64,
    );
    compare_bytes(
        "bytes_slice",
        &bytes,
        20000,
        slice_generated,
        slice_reference,
        |value| value.len() as u64,
    );
    compare_bytes(
        "bytes_concat",
        &bytes,
        10000,
        GENERATED_JOIN,
        join_reference,
        |value| value.len() as u64,
    );
    compare(
        "bytes_roundtrip",
        &texts,
        4000,
        roundtrip_generated,
        roundtrip_reference,
        |value| value.len() as u64,
    );
}