Struct naga::UniqueArena

pub struct UniqueArena<T> { /* private fields */ }

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.

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 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.

Trait Implementations

impl<'a, T> Arbitrary<'a> for UniqueArena<T> where
    T: Eq + Hash + Arbitrary<'a>, 

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

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.