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

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.

pub(crate) fn drain_all(&mut self) -> UniqueArenaDrain<'_, T>

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

pub fn iter( &self, ) -> impl DoubleEndedIterator<Item = (Handle<T>, &T)> + 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<'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.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

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

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

fn len(&self) -> usize

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

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: Write>( &self, inner: &TypeInner, out: &mut W, ) -> Result

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

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

Write the WGSL form of override to out.

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

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

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

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

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

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

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

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

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

Write the Scalar scalar as a WGSL type.

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

Write the TypeResolution resolution as a WGSL type.

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

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

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