bitcoinleveldb-coding 0.1.19

Low-level LevelDB-compatible binary coding primitives for bitcoin-rs: fixed-width little-endian, varint, and length-prefixed encoding/decoding over raw pointers, Strings, and Slices.
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

// ---------------- [ File: bitcoinleveldb-coding/src/encode_varint.rs ]
crate::ix!();

/**
  | Lower-level versions of Put... that write
  | directly into a character buffer and return
  | a pointer just past the last byte written.
  |
  | REQUIRES: dst has enough space for the value
  | being written
  */
pub fn encode_varint32(dst: *mut u8, v: u32) -> *mut u8 {
    unsafe {
        trace!(
            ptr = ?dst,
            value = v,
            "encode_varint32: encoding 32-bit varint"
        );
        let mut ptr = dst;
        const B: u32 = 128;

        if v < (1 << 7) {
            *ptr = v as u8;
            ptr = ptr.add(1);
        } else if v < (1 << 14) {
            *ptr = (v | B) as u8;
            ptr = ptr.add(1);
            *ptr = (v >> 7) as u8;
            ptr = ptr.add(1);
        } else if v < (1 << 21) {
            *ptr = (v | B) as u8;
            ptr = ptr.add(1);
            *ptr = ((v >> 7) | B) as u8;
            ptr = ptr.add(1);
            *ptr = (v >> 14) as u8;
            ptr = ptr.add(1);
        } else if v < (1 << 28) {
            *ptr = (v | B) as u8;
            ptr = ptr.add(1);
            *ptr = ((v >> 7) | B) as u8;
            ptr = ptr.add(1);
            *ptr = ((v >> 14) | B) as u8;
            ptr = ptr.add(1);
            *ptr = (v >> 21) as u8;
            ptr = ptr.add(1);
        } else {
            *ptr = (v | B) as u8;
            ptr = ptr.add(1);
            *ptr = ((v >> 7) | B) as u8;
            ptr = ptr.add(1);
            *ptr = ((v >> 14) | B) as u8;
            ptr = ptr.add(1);
            *ptr = ((v >> 21) | B) as u8;
            ptr = ptr.add(1);
            *ptr = (v >> 28) as u8;
            ptr = ptr.add(1);
        }

        trace!(
            end_ptr = ?ptr,
            "encode_varint32: finished encoding varint32"
        );
        ptr
    }
}

pub fn encode_varint64(dst: *mut u8, v: u64) -> *mut u8 {
    unsafe {
        trace!(
            ptr = ?dst,
            value = v,
            "encode_varint64: encoding 64-bit varint"
        );
        let mut ptr = dst;
        let mut val = v;
        const B: u8 = 128;

        while val >= B as u64 {
            *ptr = (val as u8) | B;
            ptr = ptr.add(1);
            val >>= 7;
        }

        *ptr = val as u8;
        ptr = ptr.add(1);

        trace!(
            end_ptr = ?ptr,
            "encode_varint64: finished encoding varint64"
        );
        ptr
    }
}