[−][src]Struct intaglio::SymbolTable
UTF-8 string interner.
This symbol table is implemented by leaking UTF-8 strings with a fast path for
&str
that are already 'static
.
Usage
let mut table = SymbolTable::new(); let sym = table.intern("abc")?; assert_eq!(sym, table.intern("abc".to_string())?); assert!(table.contains(sym)); assert!(table.is_interned("abc"));
Implementations
impl SymbolTable<RandomState>
[src]
#[must_use]pub fn new() -> Self
[src]
Constructs a new, empty SymbolTable
with
default capacity.
Examples
let table = SymbolTable::new(); assert_eq!(0, table.len()); assert!(table.capacity() >= 4096);
#[must_use]pub fn with_capacity(capacity: usize) -> Self
[src]
Constructs a new, empty SymbolTable
with the specified capacity.
The symbol table will be able to hold at least capacity
bytestrings
without reallocating. If capacity
is 0, the symbol table will not
allocate.
Examples
let table = SymbolTable::with_capacity(10); assert_eq!(0, table.len()); assert!(table.capacity() >= 10);
impl<S> SymbolTable<S>
[src]
pub fn with_hasher(hash_builder: S) -> Self
[src]
Constructs a new, empty SymbolTable
with
default capacity and the given hash
builder.
Examples
let hash_builder = RandomState::new(); let table = SymbolTable::with_hasher(hash_builder); assert_eq!(0, table.len()); assert!(table.capacity() >= 4096);
pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> Self
[src]
Constructs a new, empty SymbolTable
with the specified capacity and
the given hash builder.
Examples
let hash_builder = RandomState::new(); let table = SymbolTable::with_capacity_and_hasher(10, hash_builder); assert_eq!(0, table.len()); assert!(table.capacity() >= 10);
pub fn capacity(&self) -> usize
[src]
Returns the number of bytestrings the table can hold without reallocating.
Examples
let table = SymbolTable::with_capacity(10); assert!(table.capacity() >= 10);
pub fn len(&self) -> usize
[src]
Returns the number of interned bytestrings in the table.
Examples
let mut table = SymbolTable::new(); assert_eq!(0, table.len()); table.intern("abc")?; // only uniquely interned bytestrings grow the symbol table. table.intern("abc")?; table.intern("xyz")?; assert_eq!(2, table.len());
pub fn is_empty(&self) -> bool
[src]
Returns true
if the symbol table contains no interned bytestrings.
Examples
let mut table = SymbolTable::new(); assert!(table.is_empty()); table.intern("abc")?; assert!(!table.is_empty());
#[must_use]pub fn contains(&self, id: Symbol) -> bool
[src]
Returns true
if the symbol table contains the given symbol.
Examples
let mut table = SymbolTable::new(); assert!(!table.contains(Symbol::new(0))); let sym = table.intern("abc")?; assert!(table.contains(Symbol::new(0))); assert!(table.contains(sym));
#[must_use]pub fn get(&self, id: Symbol) -> Option<&str>
[src]
Returns a reference to the byte string associated with the given symbol.
If the given symbol does not exist in the underlying symbol table,
None
is returned.
The lifetime of the returned reference is bound to the symbol table.
Examples
let mut table = SymbolTable::new(); assert!(table.get(Symbol::new(0)).is_none()); let sym = table.intern("abc".to_string())?; assert_eq!(Some("abc"), table.get(Symbol::new(0))); assert_eq!(Some("abc"), table.get(sym));
pub fn iter(&self) -> Iter
[src]
Returns an iterator over all Symbol
s and bytestrings in the
SymbolTable
.
Examples
let mut table = SymbolTable::new(); table.intern("abc")?; table.intern("xyz")?; table.intern("123")?; table.intern("789")?; let iter = table.iter(); let mut map = HashMap::new(); map.insert(Symbol::new(0), "abc"); map.insert(Symbol::new(1), "xyz"); map.insert(Symbol::new(2), "123"); map.insert(Symbol::new(3), "789"); assert_eq!(map, iter.collect::<HashMap<_, _>>());
let mut table = SymbolTable::new(); table.intern("abc")?; table.intern("xyz")?; table.intern("123")?; table.intern("789")?; let iter = table.iter(); assert_eq!(table.len(), iter.count());
pub fn all_symbols(&self) -> AllSymbols
[src]
Returns an iterator over all Symbol
s in the SymbolTable
.
Examples
let mut table = SymbolTable::new(); table.intern("abc")?; table.intern("xyz")?; table.intern("123")?; table.intern("789")?; let mut all_symbols = table.all_symbols(); assert_eq!(Some(Symbol::new(0)), all_symbols.next()); assert_eq!(Some(Symbol::new(1)), all_symbols.nth_back(2)); assert_eq!(None, all_symbols.next());
let mut table = SymbolTable::new(); table.intern("abc")?; table.intern("xyz")?; table.intern("123")?; table.intern("789")?; let all_symbols = table.all_symbols(); assert_eq!(table.len(), all_symbols.count());
pub fn strings(&self) -> Strings
[src]
Returns an iterator over all strings in the SymbolTable
.
Examples
let mut table = SymbolTable::new(); table.intern("abc")?; table.intern("xyz")?; table.intern("123")?; table.intern("789")?; let mut strings = table.strings(); assert_eq!(Some("abc"), strings.next()); assert_eq!(Some("xyz"), strings.nth_back(2)); assert_eq!(None, strings.next());
let mut table = SymbolTable::new(); table.intern("abc")?; table.intern("xyz")?; table.intern("123")?; table.intern("789")?; let strings = table.strings(); assert_eq!(table.len(), strings.count());
impl<S> SymbolTable<S> where
S: BuildHasher,
[src]
S: BuildHasher,
pub fn intern<T>(&mut self, contents: T) -> Result<Symbol, SymbolOverflowError> where
T: Into<Cow<'static, str>>,
[src]
T: Into<Cow<'static, str>>,
Intern a bytestring for the lifetime of the symbol table.
The returned Symbol
allows retrieving of the underlying bytes.
Equal bytestrings will be inserted into the symbol table exactly once.
This function only allocates if the underlying symbol table has no remaining capacity.
Errors
If the symbol table would grow larger than u32::MAX
interned
bytestrings, the Symbol
counter would overflow and a
SymbolOverflowError
is returned.
Examples
let mut table = SymbolTable::new(); let sym = table.intern("abc".to_string())?; table.intern("xyz".to_string())?; table.intern("123")?; table.intern("789")?; assert_eq!(4, table.len()); assert_eq!(Some("abc"), table.get(sym));
#[must_use]pub fn check_interned(&self, contents: &str) -> Option<Symbol>
[src]
Returns the Symbol
identifier for contents
if it has been interned
before, None
otherwise.
This method does not modify the symbol table.
Examples
let mut table = SymbolTable::new(); assert!(!table.is_interned("abc")); assert_eq!(None, table.check_interned("abc")); table.intern("abc".to_string())?; assert!(table.is_interned("abc")); assert_eq!(Some(Symbol::new(0)), table.check_interned("abc"));
#[must_use]pub fn is_interned(&self, contents: &str) -> bool
[src]
Returns true
if the given byte string has been interned before.
This method does not modify the symbol table.
Examples
let mut table = SymbolTable::new(); assert!(!table.is_interned("abc")); assert_eq!(None, table.check_interned("abc")); table.intern("abc".to_string())?; assert!(table.is_interned("abc")); assert_eq!(Some(Symbol::new(0)), table.check_interned("abc"));
pub fn reserve(&mut self, additional: usize)
[src]
Reserves capacity for at least additional more elements to be inserted
in the given SymbolTable
. The collection may reserve more space to
avoid frequent reallocations. After calling reserve, capacity will be
greater than or equal to self.len() + additional
. Does nothing if
capacity is already sufficient.
Panics
Panics if the new capacity overflows usize
.
Examples
let mut table = SymbolTable::with_capacity(1); table.intern("abc")?; table.reserve(10); assert!(table.capacity() >= 11);
pub fn shrink_to_fit(&mut self)
[src]
Shrinks the capacity of the symbol table as much as possible.
It will drop down as close as possible to the length but the allocator may still inform the symbol table that there is space for a few more elements.
Examples
let mut table = SymbolTable::with_capacity(10); table.intern("abc")?; table.intern("xyz")?; table.intern("123")?; table.shrink_to_fit(); assert!(table.capacity() >= 3);
Trait Implementations
impl<S: Debug> Debug for SymbolTable<S>
[src]
impl<S: Default> Default for SymbolTable<S>
[src]
fn default() -> SymbolTable<S>
[src]
impl<'a> IntoIterator for &'a SymbolTable
[src]
Auto Trait Implementations
impl<S> RefUnwindSafe for SymbolTable<S> where
S: RefUnwindSafe,
S: RefUnwindSafe,
impl<S> Send for SymbolTable<S> where
S: Send,
S: Send,
impl<S> Sync for SymbolTable<S> where
S: Sync,
S: Sync,
impl<S> Unpin for SymbolTable<S> where
S: Unpin,
S: Unpin,
impl<S> UnwindSafe for SymbolTable<S> where
S: UnwindSafe,
S: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,