oxicode 0.2.2

A modern binary serialization library - successor to bincode
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Configuration and advanced features example

use oxicode::{config, Decode, Encode};

#[derive(Debug, Clone, PartialEq, Encode, Decode)]
struct Data {
    id: u64,
    values: Vec<i32>,
}

fn main() -> Result<(), oxicode::Error> {
    println!("OxiCode Configuration Examples\n");

    let data = Data {
        id: 12345,
        values: vec![1, 2, 3, -100, 1000],
    };

    // Example 1: Standard configuration (little-endian + varint)
    println!("1. Standard configuration:");
    let cfg = config::standard();
    let bytes = oxicode::encode_to_vec_with_config(&data, cfg)?;
    println!("   Size: {} bytes (varint encoding)", bytes.len());
    let (decoded, _): (Data, _) = oxicode::decode_from_slice_with_config(&bytes, cfg)?;
    assert_eq!(data, decoded);
    println!("   ✓ Verified\n");

    // Example 2: Legacy configuration (bincode 1.0 compatible)
    println!("2. Legacy configuration (bincode 1.0 compatible):");
    let cfg = config::legacy();
    let bytes = oxicode::encode_to_vec_with_config(&data, cfg)?;
    println!("   Size: {} bytes (fixed-int encoding)", bytes.len());
    let (decoded, _): (Data, _) = oxicode::decode_from_slice_with_config(&bytes, cfg)?;
    assert_eq!(data, decoded);
    println!("   ✓ Compatible with bincode 1.0\n");

    // Example 3: Big-endian encoding
    println!("3. Big-endian encoding:");
    let cfg = config::standard().with_big_endian();
    let bytes = oxicode::encode_to_vec_with_config(&data, cfg)?;
    println!("   Size: {} bytes", bytes.len());
    let (decoded, _): (Data, _) = oxicode::decode_from_slice_with_config(&bytes, cfg)?;
    assert_eq!(data, decoded);
    println!("   ✓ Big-endian verified\n");

    // Example 4: Fixed-int encoding
    println!("4. Fixed-int encoding:");
    let cfg = config::standard().with_fixed_int_encoding();
    let bytes = oxicode::encode_to_vec_with_config(&data, cfg)?;
    println!("   Size: {} bytes (no varint compression)", bytes.len());
    let (decoded, _): (Data, _) = oxicode::decode_from_slice_with_config(&bytes, cfg)?;
    assert_eq!(data, decoded);
    println!("   ✓ Fixed-int verified\n");

    // Example 5: Memory limit
    println!("5. Memory limit configuration:");
    let cfg = config::standard().with_limit::<1024>();
    let small_data = Data {
        id: 1,
        values: vec![1, 2, 3],
    };
    let bytes = oxicode::encode_to_vec_with_config(&small_data, cfg)?;
    println!("   Small data: {} bytes (within 1KB limit)", bytes.len());
    let (decoded, _): (Data, _) = oxicode::decode_from_slice_with_config(&bytes, cfg)?;
    assert_eq!(small_data, decoded);
    println!("   ✓ Within limit\n");

    // Example 6: Encoding to fixed buffer
    println!("6. Encoding to fixed buffer:");
    let mut buffer = [0u8; 256];
    let cfg = config::standard();
    let bytes_written = oxicode::encode_into_slice(data.clone(), &mut buffer, cfg)?;
    println!("   Wrote {} bytes to buffer", bytes_written);
    let (decoded, _): (Data, _) = oxicode::decode_from_slice(&buffer[..bytes_written])?;
    assert_eq!(data, decoded);
    println!("   ✓ Fixed buffer encoding works\n");

    // Example 7: Comparison of configurations
    println!("7. Configuration size comparison:");
    let test_value = 1000u64;

    let standard = oxicode::encode_to_vec_with_config(&test_value, config::standard())?;
    let legacy = oxicode::encode_to_vec_with_config(&test_value, config::legacy())?;
    let big_endian =
        oxicode::encode_to_vec_with_config(&test_value, config::standard().with_big_endian())?;

    println!("   Value: {}", test_value);
    println!(
        "   Standard (varint, little-endian): {} bytes",
        standard.len()
    );
    println!(
        "   Legacy (fixed, little-endian):    {} bytes",
        legacy.len()
    );
    println!(
        "   Big-endian (varint, big-endian):  {} bytes",
        big_endian.len()
    );
    println!("   ✓ Varint saves space for small values\n");

    println!("All configuration examples completed successfully!");

    Ok(())
}