bitcoin-serialize 0.1.19

tools for serialization
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

// ---------------- [ File: bitcoin-serialize/src/read_write.rs ]
crate::ix!();

/// Execute a *read* operation (`fn_`) during a **serialize** phase.  
/// Exists for parity with the C++ helpers; the closure performs the
/// actual work.
#[inline]
pub fn ser_read_with_action_serialize<Stream, T, F>(
    s: &mut Stream,
    _ser_action: SerActionSerialize,
    obj: T,
    fn_: F,
) where
    Stream: Write,
    F: FnOnce(&mut Stream, T),
{
    trace!("ser_read_with_action_serialize");
    fn_(s, obj);
}

/// Execute a *read* operation (`fn_`) during an **unserialize** phase.
#[inline]
pub fn ser_read<Stream, T, F>(
    s: &mut Stream,
    _ser_action: SerActionUnserialize,
    obj: T,
    fn_: F,
) where
    Stream: Read,
    F: FnOnce(&mut Stream, T),
{
    trace!("ser_read");
    fn_(s, obj);
}

/// Execute a *write* operation (`fn_`) during a **serialize** phase.
#[inline]
pub fn ser_write_with_action_serialize<Stream, T, F>(
    s: &mut Stream,
    _ser_action: SerActionSerialize,
    obj: T,
    fn_: F,
) where
    Stream: Write,
    F: FnOnce(&mut Stream, T),
{
    trace!("ser_write_with_action_serialize");
    fn_(s, obj);
}

/// Execute a *write* operation (`fn_`) during an **unserialize** phase.  
/// This is typically a no‑op but is defined for completeness.
#[inline]
pub fn ser_write_with_action_unserialize<Stream, T, F>(
    _s: &mut Stream,
    _ser_action: SerActionUnserialize,
    _obj: T,
    _fn_: F,
) where
    Stream: Read,
    F: FnOnce(&mut Stream, T),
{
    trace!("ser_write_with_action_unserialize (noop)");
}

#[cfg(test)]
mod read_write_phase_tests {
    use super::*;
    use std::io::Cursor;

    #[traced_test]
    fn serialize_phase_invokes_closure() {
        let mut buf = Cursor::new(Vec::<u8>::new());
        let value   = 0xAAu8;

        let mut hit = false;
        ser_read_with_action_serialize(
            &mut buf,
            SerActionSerialize {},
            value,
            |s, v| {
                hit = true;
                crate::read_write_data::ser_writedata8(s, v);
            },
        );
        assert!(hit);
        assert_eq!(buf.get_ref().as_slice(), &[0xAA]);
    }

    #[traced_test]
    fn unserialize_phase_invokes_closure() {
        let mut buf = Cursor::new(vec![0xBB]);
        let mut out = 0u8;
        ser_read(
            &mut buf,
            SerActionUnserialize {},
            &mut out,
            |s, tgt| {
                *tgt = crate::read_write_data::ser_readdata8(s);
            },
        );
        assert_eq!(out, 0xBB);
        assert_eq!(buf.position(), 1);
    }

    #[traced_test]
    fn write_helpers_roundtrip() {
        let mut buf = Cursor::new(Vec::<u8>::new());
        ser_write_with_action_serialize(
            &mut buf,
            SerActionSerialize {},
            0xCCu8,
            |s, v| crate::read_write_data::ser_writedata8(s, v),
        );
        buf.set_position(0);

        ser_write_with_action_unserialize(
            &mut buf,
            SerActionUnserialize {},
            (),
            |_s, _| {
                // no‑op – the API explicitly does nothing on read‑phase.
            },
        );
    }
}