qubit-io 0.4.0

Small stream I/O trait utilities for Rust
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

/*******************************************************************************
 *
 *    Copyright (c) 2026 Haixing Hu.
 *
 *    SPDX-License-Identifier: Apache-2.0
 *
 *    Licensed under the Apache License, Version 2.0.
 *
 ******************************************************************************/

use std::io::{
    Result,
    Write,
};

use crate::codec::{
    Leb128Codec,
    NonStrict,
};

macro_rules! write_leb128_value {
    ($writer:expr, $value:expr, $ty:ty) => {
        write_leb128::<{ Leb128Codec::<$ty, NonStrict>::REQUIRED_MIN_BUFFER_LEN }, _, _, _>(
            $writer,
            $value,
            |bytes, value| {
                // SAFETY: The local buffer is exactly the codec's minimum buffer length.
                unsafe { Leb128Codec::<$ty, NonStrict>::write_unchecked(bytes, 0, value) }
            },
        )
    };
}

/// Extension methods for writing canonical LEB128 integers to byte streams.
///
/// # Target-width integers
///
/// `usize` and `isize` methods use the current Rust target's pointer width.
/// Prefer fixed-width integer methods such as [`Self::write_uleb_u64`] or
/// [`Self::write_sleb_i64`] for persistent files and cross-platform protocols.
pub trait Leb128WriteExt: Write {
    /// Writes an unsigned LEB128 `u8`.
    #[inline]
    fn write_uleb_u8(&mut self, value: u8) -> Result<()> {
        write_leb128_value!(self, value, u8)
    }

    /// Writes an unsigned LEB128 `u16`.
    #[inline]
    fn write_uleb_u16(&mut self, value: u16) -> Result<()> {
        write_leb128_value!(self, value, u16)
    }

    /// Writes an unsigned LEB128 `u32`.
    #[inline]
    fn write_uleb_u32(&mut self, value: u32) -> Result<()> {
        write_leb128_value!(self, value, u32)
    }

    /// Writes an unsigned LEB128 `u64`.
    #[inline]
    fn write_uleb_u64(&mut self, value: u64) -> Result<()> {
        write_leb128_value!(self, value, u64)
    }

    /// Writes an unsigned LEB128 `u128`.
    #[inline]
    fn write_uleb_u128(&mut self, value: u128) -> Result<()> {
        write_leb128_value!(self, value, u128)
    }

    /// Writes an unsigned LEB128 `usize`.
    #[inline]
    fn write_uleb_usize(&mut self, value: usize) -> Result<()> {
        write_leb128_value!(self, value, usize)
    }

    /// Writes a signed LEB128 `i8`.
    #[inline]
    fn write_sleb_i8(&mut self, value: i8) -> Result<()> {
        write_leb128_value!(self, value, i8)
    }

    /// Writes a signed LEB128 `i16`.
    #[inline]
    fn write_sleb_i16(&mut self, value: i16) -> Result<()> {
        write_leb128_value!(self, value, i16)
    }

    /// Writes a signed LEB128 `i32`.
    #[inline]
    fn write_sleb_i32(&mut self, value: i32) -> Result<()> {
        write_leb128_value!(self, value, i32)
    }

    /// Writes a signed LEB128 `i64`.
    #[inline]
    fn write_sleb_i64(&mut self, value: i64) -> Result<()> {
        write_leb128_value!(self, value, i64)
    }

    /// Writes a signed LEB128 `i128`.
    #[inline]
    fn write_sleb_i128(&mut self, value: i128) -> Result<()> {
        write_leb128_value!(self, value, i128)
    }

    /// Writes a signed LEB128 `isize`.
    #[inline]
    fn write_sleb_isize(&mut self, value: isize) -> Result<()> {
        write_leb128_value!(self, value, isize)
    }
}

impl<W> Leb128WriteExt for W where W: Write + ?Sized {}

#[inline]
fn write_leb128<const N: usize, T, W, F>(writer: &mut W, value: T, encode: F) -> Result<()>
where
    W: Write + ?Sized,
    F: FnOnce(&mut [u8], T) -> usize,
{
    let mut bytes = [0u8; N];
    let len = encode(&mut bytes, value);
    writer.write_all(&bytes[..len])
}