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

use std::collections::HashMap;
use std::ops::Deref;

use abin::{BooStr, NewStr, Str, StrFactory, ToBooConverter};

#[test]
fn entity_with_borrowed_or_owned_fields() {
    let first_name = NewStr::copy_from_str("Hans");
    let first_name_clone = first_name.clone();
    let last_name = NewStr::from_static("Muster");

    let entity_borrowed_first_name = StrEntity {
        // using ToBooConverter::borrowed()
        first_name: first_name.borrowed(),
        // using From / Into (always borrowed)
        last_name: "Muster".into(),
    };
    let entity_owned_first_name = StrEntity {
        // using ToBooConverter::owned()
        first_name: first_name_clone.owned(),
        // using ToBooConverter::borrowed()
        last_name: last_name.borrowed(),
    };

    assert_eq!(
        first_name,
        extract_first_name_owned(entity_borrowed_first_name, "Muster")
    );
    assert_eq!(
        first_name,
        extract_first_name_owned(entity_owned_first_name, "Muster")
    );
}

fn extract_first_name_owned<'a>(
    entity: StrEntity,
    expected_last_name: impl Into<BooStr<'a>>,
) -> Str {
    assert_eq!(entity.last_name.deref(), expected_last_name.into().deref());
    // Convert a Boo (BooStr in this case) into owned (`NewStr` is the implementation used to
    // convert "&str" to "Str" if `first_name` is borrowed).
    entity.first_name.into_owned_with::<NewStr>()
}

struct StrEntity<'a> {
    first_name: BooStr<'a>,
    last_name: BooStr<'a>,
}

#[test]
fn boo_in_hash_map() {
    // static entries: always owned.
    let mut map = HashMap::<BooStr<'static>, BooStr<'static>>::new();

    map.insert(
        NewStr::from_static("entry1").owned(),
        NewStr::from_static("Value for entry1").owned(),
    );
    map.insert(
        NewStr::from_static("entry2").owned(),
        NewStr::from_static("Value for entry2").owned(),
    );
    map.insert(
        NewStr::from_static("entry3").owned(),
        NewStr::from_static("Value for entry3").owned(),
    );

    // query the map. Can just use normal "&str".
    assert_eq!(map.get("entry1").unwrap().deref(), "Value for entry1");
    assert_eq!(map.get("entry2").unwrap().deref(), "Value for entry2");
    assert_eq!(map.get("entry3").unwrap().deref(), "Value for entry3");
}