6797a606b5
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.
69 lines
2.3 KiB
Rust
69 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()
|
|
}
|
|
}
|
|
}
|