contain 0.5.1

A crate for defining/extending lifetimes
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
103
104
105
106
107
108
109

use std::hash::Hash;

use indexmap::IndexMap;
use parking_lot::Mutex;

/**
A deduplicating [`Container`] backed by a [`indexmap::IndexMap`].
If two equal items are stored, the second is dropped
and a reference to the first is returned.
Whilst more resource-intensive than [`SimpleContainer`], it can be more memory efficient in scenarios where many
items are equal and equivalent since the duplicates will be dropped.

# Example
```
use contain::DeduplicatingContainer;

fn append_thing<'a>(container: &'a DeduplicatingContainer<'_, String>, s: &str) -> &'a str {
    container.put(format!("{}thing", s))
}

let container = DeduplicatingContainer::new();
let a = append_thing(&container, "some");
let b = append_thing(&container, "a ");
let c = append_thing(&container, "some");
assert_eq!(a, "something");
assert_eq!(b, "a thing");
assert_eq!(c, "something");
assert_eq!(container.count(), 2);
```
*/
pub struct DeduplicatingContainer<'a, T: Eq + Hash + ?Sized> {
    items: Mutex<IndexMap<&'a T, *mut T>>,
}

impl<'a, T: Eq + Hash + ?Sized> DeduplicatingContainer<'a, T> {
    #[must_use]
    pub fn new() -> Self {
        DeduplicatingContainer {
            items: Mutex::new(IndexMap::new()),
        }
    }

    #[must_use]
    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            items: Mutex::new(IndexMap::with_capacity(capacity)),
        }
    }

    pub fn count(&self) -> usize {
        self.items.lock().len()
    }
}

impl<'a, T: Eq + Hash> DeduplicatingContainer<'a, T> {
    /**
    Manage the lifetime of a given object.

    # Panics
    May panic if invariants of Eq and Hash are not upheld.
    */
    pub fn put(&self, item: T) -> &T {
        unsafe {
            let mut items = self.items.lock();
            if let Some(existing) = items.get(&item) {
                &**existing
            } else {
                let item_ref = Box::into_raw(Box::new(item));
                items.insert(&*item_ref, item_ref);
                &*item_ref
            }
        }
    }
}

impl<'a, T: Eq + Hash + ?Sized> DeduplicatingContainer<'a, T> {
    pub fn put_boxed(&self, item: Box<T>) -> &T {
        unsafe {
            let mut items = self.items.lock();
            if let Some(existing) = items.get(&*item) {
                &**existing
            } else {
                let item_ref = Box::into_raw(item);
                items.insert(&*item_ref, item_ref);
                &*item_ref
            }
        }
    }
}

impl<'a, T: Eq + Hash + ?Sized> Default for DeduplicatingContainer<'a, T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<'a, T: Eq + Hash + ?Sized> Drop for DeduplicatingContainer<'a, T> {
    fn drop(&mut self) {
        for &p in self.items.lock().values().rev() {
            unsafe {
                let _ = Box::from_raw(p);
            }
        }
    }
}

unsafe impl<'a, T: Eq + Hash + Send + ?Sized> Send for DeduplicatingContainer<'a, T> {}

unsafe impl<'a, T: Eq + Hash + Send + Sync + ?Sized> Sync for DeduplicatingContainer<'a, T> {}