bitcoin-compat 0.1.19

platform specific code and constant assertions for certain assumptions
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

// ---------------- [ File: bitcoin-compat/src/endian.rs ]
//! Host ↔ Endian conversion helpers.
//
//! The original C++ code provided a large matrix of
//! `htobe*`, `htole*`, `be*toh`, and `le*toh` helpers
//! hidden behind a thicket of pre‑processor guards.
//! In Rust the same behaviour is achievable in a
//! single, portable implementation using the
//! intrinsic `[u{16,32,64}::to_be / to_le / from_be / from_le]`
//! conversions.
//!
//! All helpers are instrumented with `tracing` so any
//! misuse is surfaced immediately in production
//! deployments.
crate::ix!();

//-------------------------------------------[.cpp/bitcoin/src/compat/endian.h]

/// Convert a host‑order `u16` to big‑endian.
#[inline]
pub fn htobe16(x: u16) -> u16 {
    trace!(target: "compat::endian", func = "htobe16", input = format!("{:#06x}", x));
    let res = x.to_be();
    trace!(target: "compat::endian", func = "htobe16", output = format!("{:#06x}", res));
    res
}

/// Convert a host‑order `u16` to little‑endian.
#[inline]
pub fn htole16(x: u16) -> u16 {
    trace!(target: "compat::endian", func = "htole16", input = format!("{:#06x}", x));
    let res = x.to_le();
    trace!(target: "compat::endian", func = "htole16", output = format!("{:#06x}", res));
    res
}

/// Convert a big‑endian `u16` to host order.
#[inline]
pub fn be_16toh(x: u16) -> u16 {
    trace!(target: "compat::endian", func = "be_16toh", input = format!("{:#06x}", x));
    let res = u16::from_be(x);
    trace!(target: "compat::endian", func = "be_16toh", output = format!("{:#06x}", res));
    res
}

/// Convert a little‑endian `u16` to host order.
#[inline]
pub fn le_16toh(x: u16) -> u16 {
    trace!(target: "compat::endian", func = "le_16toh", input = format!("{:#06x}", x));
    let res = u16::from_le(x);
    trace!(target: "compat::endian", func = "le_16toh", output = format!("{:#06x}", res));
    res
}

/// Convert a host‑order `u32` to big‑endian.
#[inline]
pub fn htobe32(x: u32) -> u32 {
    trace!(target: "compat::endian", func = "htobe32", input = format!("{:#010x}", x));
    let res = x.to_be();
    trace!(target: "compat::endian", func = "htobe32", output = format!("{:#010x}", res));
    res
}

/// Convert a host‑order `u32` to little‑endian.
#[inline]
pub fn htole32(x: u32) -> u32 {
    trace!(target: "compat::endian", func = "htole32", input = format!("{:#010x}", x));
    let res = x.to_le();
    trace!(target: "compat::endian", func = "htole32", output = format!("{:#010x}", res));
    res
}

/// Convert a big‑endian `u32` to host order.
#[inline]
pub fn be_32toh(x: u32) -> u32 {
    trace!(target: "compat::endian", func = "be_32toh", input = format!("{:#010x}", x));
    let res = u32::from_be(x);
    trace!(target: "compat::endian", func = "be_32toh", output = format!("{:#010x}", res));
    res
}

/// Convert a little‑endian `u32` to host order.
#[inline]
pub fn le_32toh(x: u32) -> u32 {
    trace!(target: "compat::endian", func = "le_32toh", input = format!("{:#010x}", x));
    let res = u32::from_le(x);
    trace!(target: "compat::endian", func = "le_32toh", output = format!("{:#010x}", res));
    res
}

/// Convert a host‑order `u64` to big‑endian.
#[inline]
pub fn htobe64(x: u64) -> u64 {
    trace!(target: "compat::endian", func = "htobe64", input = format!("{:#018x}", x));
    let res = x.to_be();
    trace!(target: "compat::endian", func = "htobe64", output = format!("{:#018x}", res));
    res
}

/// Convert a host‑order `u64` to little‑endian.
#[inline]
pub fn htole64(x: u64) -> u64 {
    trace!(target: "compat::endian", func = "htole64", input = format!("{:#018x}", x));
    let res = x.to_le();
    trace!(target: "compat::endian", func = "htole64", output = format!("{:#018x}", res));
    res
}

/// Convert a big‑endian `u64` to host order.
#[inline]
pub fn be_64toh(x: u64) -> u64 {
    trace!(target: "compat::endian", func = "be_64toh", input = format!("{:#018x}", x));
    let res = u64::from_be(x);
    trace!(target: "compat::endian", func = "be_64toh", output = format!("{:#018x}", res));
    res
}

/// Convert a little‑endian `u64` to host order.
#[inline]
pub fn le_64toh(x: u64) -> u64 {
    trace!(target: "compat::endian", func = "le_64toh", input = format!("{:#018x}", x));
    let res = u64::from_le(x);
    trace!(target: "compat::endian", func = "le_64toh", output = format!("{:#018x}", res));
    res
}