mentat/core/src/intern_set.rs
Richard Newman 6797a606b5 Preliminary work for vocabulary management. r=emily,nalexander
Pre: export AttributeBuilder from mentat_db.
Pre: fix module-level comment for tx/src/entities.rs.
Pre: rename some `to_` conversions to `into_`.
Pre: make AttributeBuilder::unique less verbose.
Pre: split out a HasSchema trait to abstract over Schema.
Pre: rename SchemaMap/schema_map to AttributeMap/attribute_map.
Pre: TypedValue/NamespacedKeyword conversions.
Pre: turn Unique and ValueType into TypedValue::Keyword.
Pre: export IntoResult.
Pre: export NamespacedKeyword from mentat_core.
Pre: use intern_set in tx.
Pre: add InternSet::len.
Pre: comment gardening.
Pre: remove inaccurate TODO from TxReport comment.
2018-01-23 08:25:32 -08:00

68 lines
2.3 KiB
Rust

// 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()
}
}
}