ostr 0.1.0

Owned str
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

# ostr

Owned const str

## Rationale

This library provides owned `str` instance. It can be used in complex keys
in `HashMap` or `HashSet` without leveraging unstable raw entry API.

Example:

```rust
use ostr::Str;

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
struct SchemaKey {
    subject: Str,
    version: i32,
}

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
struct SchemaKeyRef<'a> {
    subject: &'a str,
    version: i32,
}

impl<'a> Borrow<SchemaKeyRef<'a>> for SchemaKey {
    fn borrow(&self) -> &SchemaKeyRef<'a> {
        unsafe {
            &*(self as *const SchemaKey as *const SchemaKeyRef)
        }
    }
}

fn main() {
    let mut cache: HashMap<SchemaKey, String> = HashMap::new();
    cache.insert(
        SchemaKey{subject: Str::new("User"), version: 1},
        "User:1".to_string(),
    );
    cache.insert(
        SchemaKey{subject: Str::new("User"), version: 2},
        "User:2".to_string(),
    );

    let key = SchemaKeyRef{subject: "User", version: 1};
    assert_eq!(cache.get(&key), Some(&"User:1".to_string()));
}
```

It is guarantied size of `Str` to be equal to size of `&str`.