Struct UniqueArena 

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

Available on crate feature unstable-wgpu-26 only.

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 generally may not be mutated, although a replace method exists to support rare cases.

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

Implementations

impl<T> UniqueArena<T>

pub fn new() -> UniqueArena<T>

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.

impl<T> UniqueArena<T>

where T: Eq + Hash,

pub fn iter(&self) -> impl DoubleEndedIterator + ExactSizeIterator

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.

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 for UniqueArena<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for UniqueArena<T>

where T: Debug + Eq + Hash,

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

Formats the value using the given formatter.

impl<T> Default for UniqueArena<T>

fn default() -> UniqueArena<T>

Returns the “default value” for a type.

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 TypeContext for UniqueArena<Type>

Format types as WGSL based on a UniqueArena<Type>.

This is probably only good enough for logging:

• It does not apply any kind of Namer renamings.

• It generates invalid WGSL for anonymous struct types.

• It doesn’t write override-sized arrays properly.

fn lookup_type(&self, handle: Handle<Type>) -> &Type

Return the Type referred to by handle.

fn type_name(&self, handle: Handle<Type>) -> &str

Return the name to be used for the type referred to by handle.

fn write_unnamed_struct<W>( &self, inner: &TypeInner, out: &mut W, ) -> Result<(), Error>

where W: Write,

Write a TypeInner::Struct for which we are unable to find a name.

fn write_override<W>( &self, handle: Handle<Override>, out: &mut W, ) -> Result<(), Error>

where W: Write,

Write the WGSL form of override to out.

fn write_non_wgsl_inner<W>( &self, inner: &TypeInner, out: &mut W, ) -> Result<(), Error>

where W: Write,

Write a TypeInner that has no representation as WGSL source, even including Naga extensions.

fn write_non_wgsl_scalar<W>( &self, scalar: Scalar, out: &mut W, ) -> Result<(), Error>

where W: Write,

Write a Scalar that has no representation as WGSL source, even including Naga extensions.

fn write_type<W>(&self, handle: Handle<Type>, out: &mut W) -> Result<(), Error>

where W: Write,

Write the type ty as it would appear in a value’s declaration.

fn write_type_inner<W>( &self, inner: &TypeInner, out: &mut W, ) -> Result<(), Error>

where W: Write,

Write the TypeInner inner as it would appear in a value’s declaration.

fn write_scalar<W>(&self, scalar: Scalar, out: &mut W) -> Result<(), Error>

where W: Write,

Write the Scalar scalar as a WGSL type.

fn write_type_resolution<W>( &self, resolution: &TypeResolution, out: &mut W, ) -> Result<(), Error>

where W: Write,

Write the TypeResolution resolution as a WGSL type.

fn write_type_conclusion<W>( &self, conclusion: &Conclusion, out: &mut W, ) -> Result<(), Error>

where W: Write,

fn write_type_rule<W>( &self, name: &str, rule: &Rule, out: &mut W, ) -> Result<(), Error>

where W: Write,

fn type_to_string(&self, handle: Handle<Type>) -> String

fn type_resolution_to_string(&self, resolution: &TypeResolution) -> String

fn type_rule_to_string(&self, name: &str, rule: &Rule) -> String