Struct naga::arena::UniqueArena

pub struct UniqueArena<T> {
    set: FastIndexSet<T>,
    span_info: Vec<Span>,
}

An arena whose elements are guaranteed to be unique.

A UniqueArena holds a set of unique values of type T, each with an associated Span. Inserting a value returns a Handle<T>, which can be used to index the UniqueArena and obtain shared access to the T element. Access via a Handle is an array lookup - no hash lookup is necessary.

The element type must implement Eq and Hash. Insertions of equivalent elements, according to Eq, all return the same Handle.

Once inserted, elements may not be mutated.

UniqueArena is similar to Arena: If Arena is vector-like, UniqueArena is HashSet-like.

Fields

set: FastIndexSet<T>

span_info: Vec<Span>

Spans for the elements, indexed by handle.

The length of this vector is always equal to set.len(). FastIndexSet promises that its elements “are indexed in a compact range, without holes in the range 0..set.len()”, so we can always use the indices returned by insertion as indices into this vector.

Implementations

impl<T> UniqueArena<T>

pub fn new() -> Self

Create a new arena with no initial capacity allocated.

pub fn len(&self) -> usize

Return the current number of items stored in this arena.

pub fn is_empty(&self) -> bool

Return true if the arena contains no elements.

pub fn clear(&mut self)

Clears the arena, keeping all allocations.

pub fn get_span(&self, handle: Handle<T>) -> Span

Return the span associated with handle.

If a value has been inserted multiple times, the span returned is the one provided with the first insertion.

If the span feature is not enabled, always return Span::default. This can be detected with Span::is_defined.

impl<T: Eq + Hash> UniqueArena<T>

pub fn iter(&self) -> impl DoubleEndedIterator<Item = (Handle<T>, &T)>

Returns an iterator over the items stored in this arena, returning both the item’s handle and a reference to it.

pub fn insert(&mut self, value: T, span: Span) -> Handle<T>

Insert a new value into the arena.

Return a Handle<T>, which can be used to index this arena to get a shared reference to the element.

If this arena already contains an element that is Eq to value, return a Handle to the existing element, and drop value.

When the span feature is enabled, if value is inserted into the arena, associate span with it. An element’s span can be retrieved with the get_span method.

pub fn replace(&mut self, old: Handle<T>, new: T)

Replace an old value with a new value.

Panics

• if the old value is not in the arena
• if the new value already exists in the arena

pub fn get(&self, value: &T) -> Option<Handle<T>>

Return this arena’s handle for value, if present.

If this arena already contains an element equal to value, return its handle. Otherwise, return None.

pub fn get_handle(&self, handle: Handle<T>) -> Result<&T, BadHandle>

Return this arena’s value at handle, if that is a valid handle.

pub fn check_contains_handle(&self, handle: Handle<T>) -> Result<(), BadHandle>

Assert that handle is valid for this arena.

Trait Implementations

impl<T: Clone> Clone for UniqueArena<T>

fn clone(&self) -> UniqueArena<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Eq + Hash> Debug for UniqueArena<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for UniqueArena<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for UniqueArena<T>where T: Eq + Hash + Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Index<Handle<T>> for UniqueArena<T>

type Output = T

The returned type after indexing.

fn index(&self, handle: Handle<T>) -> &T

Performs the indexing (container[index]) operation.

impl<T> Serialize for UniqueArena<T>where T: Eq + Hash + Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> SpanProvider<T> for UniqueArena<T>

fn get_span(&self, handle: Handle<T>) -> Span

fn get_span_context(&self, handle: Handle<T>) -> SpanContext