abin 0.1.6

A library for working with binaries and strings. The library tries to avoid heap-allocations / memory-copy whenever possible by automatically choosing a reasonable strategy: stack for small binaries; static-lifetime-binary or reference-counting.
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

use serde::Deserializer;

use crate::serde_support::{ReIntegrationBytesVisitor, ReIntegrator, RiScope};
use crate::{AnyRc, ArcBin, Bin, RcBin, SBin};

/// Performs re-integration de-serialization for `Bin`, see `#[serde(deserialize_with = "path")]`.
///
/// ```rust
/// use serde::{Deserialize, Serialize};
/// use abin::Bin;
///
/// #[derive(Deserialize, Serialize)]
/// struct SomeData {
///   some_number : usize,
///   #[serde(deserialize_with = "abin::ri_deserialize_bin")]
///   binary : Bin
/// }
/// ```
pub fn ri_deserialize_bin<'de, D>(deserialize: D) -> Result<Bin, D::Error>
where
    D: Deserializer<'de>,
{
    deserialize.deserialize_bytes(ReIntegrationBytesVisitor::<BinReIntegrator>::new())
}

/// Performs re-integration de-serialization for `SBin`, see `#[serde(deserialize_with = "path")]`.
///
/// ```rust
/// use serde::{Deserialize, Serialize};
/// use abin::SBin;
///
/// #[derive(Deserialize, Serialize)]
/// struct SomeData {
///   some_number : usize,
///   #[serde(deserialize_with = "abin::ri_deserialize_sbin")]
///   binary : SBin
/// }
/// ```
pub fn ri_deserialize_sbin<'de, D>(deserialize: D) -> Result<SBin, D::Error>
where
    D: Deserializer<'de>,
{
    deserialize.deserialize_bytes(ReIntegrationBytesVisitor::<SyncBinReIntegrator>::new())
}

/// re-integrator for `Bin`.
struct BinReIntegrator {}

impl ReIntegrator for BinReIntegrator {
    type TBin = Bin;

    #[inline]
    fn re_integrate(slice: &[u8]) -> Self::TBin {
        if let Some(bin) = RiScope::try_re_integrate(slice) {
            // nice, could re-integrate
            bin
        } else {
            // bad!
            RcBin::copy_from_slice(slice)
        }
    }

    #[inline]
    fn vec(vec: Vec<u8>) -> Self::TBin {
        // can't do much here...
        RcBin::from_vec(vec)
    }

    #[inline]
    fn overhead_bytes_for_vec() -> usize {
        RcBin::overhead_bytes()
    }
}

/// re-integrator for `SyncBin`.
struct SyncBinReIntegrator {}

impl ReIntegrator for SyncBinReIntegrator {
    type TBin = SBin;

    #[inline]
    fn re_integrate(slice: &[u8]) -> Self::TBin {
        if let Some(bin) = RiScope::try_re_integrate_sync(slice) {
            // nice, could re-integrate
            bin
        } else {
            // bad!
            ArcBin::copy_from_slice(slice)
        }
    }

    #[inline]
    fn vec(vec: Vec<u8>) -> Self::TBin {
        // can't do much here...
        ArcBin::from_vec(vec)
    }

    #[inline]
    fn overhead_bytes_for_vec() -> usize {
        ArcBin::overhead_bytes()
    }
}