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

// Copyright 2016 Mozilla
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
// this file except in compliance with the License. You may obtain a copy of the
// License at http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#![allow(dead_code)]

use std::collections::HashSet;
use std::hash::Hash;
use std::rc::Rc;

/// An `InternSet` allows to "intern" some potentially large values, maintaining a single value
/// instance owned by the `InternSet` and leaving consumers with lightweight ref-counted handles to
/// the large owned value.  This can avoid expensive clone() operations.
///
/// In Mentat, such large values might be strings or arbitrary [a v] pairs.
///
/// See https://en.wikipedia.org/wiki/String_interning for discussion.
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct InternSet<T> where T: Eq + Hash {
    pub inner: HashSet<Rc<T>>,
}

impl<T> InternSet<T> where T: Eq + Hash {
    pub fn new() -> InternSet<T> {
        InternSet {
            inner: HashSet::new(),
        }
    }

    pub fn len(&self) -> usize {
        self.inner.len()
    }

    /// Intern a value, providing a ref-counted handle to the interned value.
    ///
    /// ```
    /// use std::rc::Rc;
    /// use mentat_core::intern_set::InternSet;
    ///
    /// let mut s = InternSet::new();
    ///
    /// let one = "foo".to_string();
    /// let two = Rc::new("foo".to_string());
    ///
    /// let out_one = s.intern(one);
    /// assert_eq!(out_one, two);
    /// // assert!(!&out_one.ptr_eq(&two));      // Nightly-only.
    ///
    /// let out_two = s.intern(two);
    /// assert_eq!(out_one, out_two);
    /// assert_eq!(1, s.inner.len());
    /// // assert!(&out_one.ptr_eq(&out_two));   // Nightly-only.
    /// ```
    pub fn intern<R: Into<Rc<T>>>(&mut self, value: R) -> Rc<T> {
        let key: Rc<T> = value.into();
        if self.inner.insert(key.clone()) {
            key
        } else {
            self.inner.get(&key).unwrap().clone()
        }
    }
}