hex-buffer-serde 0.4.0

Helper for serializing byte buffers as hex strings in `serde`
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

//! Example demonstrating how to use the crate with external types which don't implement
//! any "useful" traits (e.g., `AsRef<[u8]>` or `FromHex`).
//!
//! Also, checks that the crate is usable with `no_std`.

#![no_std]

extern crate alloc;

use ed25519_compact::PublicKey;
use serde_derive::*;

use alloc::{
    borrow::{Cow, ToOwned},
    string::String,
};

use hex_buffer_serde::Hex;

struct PublicKeyHex(());

impl Hex<PublicKey> for PublicKeyHex {
    type Error = ed25519_compact::Error;

    fn create_bytes(value: &PublicKey) -> Cow<'_, [u8]> {
        Cow::Borrowed(&value[..])
    }

    fn from_bytes(bytes: &[u8]) -> Result<PublicKey, Self::Error> {
        PublicKey::from_slice(bytes)
    }
}

#[derive(Serialize, Deserialize)]
struct SomeData {
    #[serde(with = "PublicKeyHex")]
    public_key: PublicKey,
    name: Option<String>,
}

fn main() {
    let public_key =
        hex::decode("06fac1f22240cffd637ead6647188429fafda9c9cb7eae43386ac17f61115075").unwrap();
    let public_key = PublicKey::from_slice(&public_key).unwrap();

    let key_hex = hex::encode(&public_key[..]);

    let data = SomeData {
        public_key,
        name: Some("our precious".to_owned()),
    };

    let json = serde_json::to_string_pretty(&data).unwrap();
    assert!(json.contains(&key_hex));

    let bin = bincode::serialize(&data).unwrap();
    assert!(bin
        .windows(key_hex.len())
        .all(|window| window != key_hex.as_bytes()));
    let bin = hex::encode(&bin);
    assert!(bin.contains(&key_hex));
}