Trait Intern

pub trait Intern {
    type Symbol: Copy;
    type Error;

    const SYMBOL_RANGE_START: Self::Symbol;

    // Required methods
    fn intern_bytes<T>(
        &mut self,
        symbol: T,
    ) -> Result<Self::Symbol, Self::Error>
       where T: Into<Cow<'static, [u8]>>;
    fn check_interned_bytes(
        &self,
        symbol: &[u8],
    ) -> Result<Option<Self::Symbol>, Self::Error>;
    fn lookup_symbol(
        &self,
        symbol: Self::Symbol,
    ) -> Result<Option<&[u8]>, Self::Error>;
    fn symbol_count(&self) -> usize;

    // Provided methods
    fn intern_string<T>(
        &mut self,
        symbol: T,
    ) -> Result<Self::Symbol, Self::Error>
       where T: Into<Cow<'static, str>> { ... }
    fn check_interned_string(
        &self,
        symbol: &str,
    ) -> Result<Option<Self::Symbol>, Self::Error> { ... }
}

Store and retrieve byte strings that have the same lifetime as the interpreter.

See the Ruby Symbol type.

Required Associated Constants

const SYMBOL_RANGE_START: Self::Symbol

The initial Symbol index returned by the interner.

Implementing Intern requires that symbol identifiers form an arithmetic progression with a common difference of 1. The sequence of symbol identifiers must be representable by a Range<u32>.

Required Associated Types

type Symbol: Copy

Concrete type for symbol identifiers.

The symbol identifier enables lookups in the underlying storage.

type Error

Concrete type for errors returned while interning symbols.

Required Methods

fn intern_bytes<T>(&mut self, symbol: T) -> Result<Self::Symbol, Self::Error>

where T: Into<Cow<'static, [u8]>>,

Store an immutable byte string for the life of the interpreter.

Returns an identifier that enables retrieving the original bytes.

Errors

If the symbol store cannot be accessed, an error is returned.

If the symbol table overflows, an error is returned.

fn check_interned_bytes( &self, symbol: &[u8], ) -> Result<Option<Self::Symbol>, Self::Error>

Check if a byte string is already interned and return its symbol identifier. Return None if the string has not been interned before.

Returns an identifier that enables retrieving the original bytes.

Errors

If the symbol store cannot be accessed, an error is returned.

fn lookup_symbol( &self, symbol: Self::Symbol, ) -> Result<Option<&[u8]>, Self::Error>

Retrieve the original byte content of an interned byte string.

Returns None if the symbol identifier is invalid.

Errors

If the symbol store cannot be accessed, an error is returned.

fn symbol_count(&self) -> usize

Retrieve the number of unique strings interned.

This method should return the length of the underlying symbol table.

Provided Methods

fn intern_string<T>(&mut self, symbol: T) -> Result<Self::Symbol, Self::Error>

where T: Into<Cow<'static, str>>,

Store an immutable string for the life of the interpreter.

Returns an identifier that enables retrieving the original bytes.

By default, this method is implemented by delegating to intern_bytes.

Errors

If the symbol store cannot be accessed, an error is returned.

If the symbol table overflows, an error is returned.

fn check_interned_string( &self, symbol: &str, ) -> Result<Option<Self::Symbol>, Self::Error>

Check if a string is already interned and return its symbol identifier. Return None if the string has not been interned before.

Returns an identifier that enables retrieving the original bytes.

By default, this method is implemented by delegating to check_interned_bytes.

Errors

If the symbol store cannot be accessed, an error is returned.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Intern for Artichoke

const SYMBOL_RANGE_START: Self::Symbol = {transmute(0x00000001): <artichoke::Artichoke as artichoke_core::intern::Intern>::Symbol}

type Symbol = u32

type Error = Error