Type Alias ValueList

pub type ValueList = EntityList<Value>;

Some instructions use an external list of argument values because there is not enough space in the 16-byte InstructionData struct. These value lists are stored in a memory pool in dfg.value_lists.

Aliased Type

struct ValueList { /* private fields */ }

Implementations

impl<T> EntityList<T>

where T: EntityRef + ReservedValue,

pub fn new() -> EntityList<T>

Create a new empty list.

pub fn from_slice(slice: &[T], pool: &mut ListPool<T>) -> EntityList<T>

Create a new list with the contents initialized from a slice.

pub fn is_empty(&self) -> bool

Returns true if the list has a length of 0.

pub fn len(&self, pool: &ListPool<T>) -> usize

Get the number of elements in the list.

pub fn is_valid(&self, pool: &ListPool<T>) -> bool

Returns true if the list is valid

pub fn as_slice<'a>(&self, pool: &'a ListPool<T>) -> &'a [T]

Get the list as a slice.

pub fn get(&self, index: usize, pool: &ListPool<T>) -> Option<T>

Get a single element from the list.

pub fn first(&self, pool: &ListPool<T>) -> Option<T>

Get the first element from the list.

pub fn as_mut_slice<'a>(&'a mut self, pool: &'a mut ListPool<T>) -> &'a mut [T]

Get the list as a mutable slice.

pub fn get_mut<'a>( &'a mut self, index: usize, pool: &'a mut ListPool<T>, ) -> Option<&'a mut T>

Get a mutable reference to a single element from the list.

pub fn deep_clone(&self, pool: &mut ListPool<T>) -> EntityList<T>

Create a deep clone of the list, which does not alias the original list.

pub fn clear(&mut self, pool: &mut ListPool<T>)

Removes all elements from the list.

The memory used by the list is put back in the pool.

pub fn take(&mut self) -> EntityList<T>

Take all elements from this list and return them as a new list. Leave this list empty.

This is the equivalent of Option::take().

pub fn push(&mut self, element: T, pool: &mut ListPool<T>) -> usize

Appends an element to the back of the list. Returns the index where the element was inserted.

pub fn from_iter<I>(elements: I, pool: &mut ListPool<T>) -> EntityList<T>

where I: IntoIterator<Item = T>,

Constructs a list from an iterator.

pub fn extend<I>(&mut self, elements: I, pool: &mut ListPool<T>)

where I: IntoIterator<Item = T>,

Appends multiple elements to the back of the list.

pub fn copy_from( &mut self, other: &EntityList<T>, slice: impl RangeBounds<usize>, index: usize, pool: &mut ListPool<T>, )

Copies a slice from an entity list in the same pool to a position in this one.

Will panic if self is the same list as other.

pub fn insert(&mut self, index: usize, element: T, pool: &mut ListPool<T>)

Inserts an element as position index in the list, shifting all elements after it to the right.

pub fn remove(&mut self, index: usize, pool: &mut ListPool<T>)

Removes the element at position index from the list. Potentially linear complexity.

pub fn swap_remove(&mut self, index: usize, pool: &mut ListPool<T>)

Removes the element at index in constant time by switching it with the last element of the list.

pub fn truncate(&mut self, new_len: usize, pool: &mut ListPool<T>)

Shortens the list down to len elements.

Does nothing if the list is already shorter than len.

pub fn grow_at(&mut self, index: usize, count: usize, pool: &mut ListPool<T>)

Grow the list by inserting count elements at index.

The new elements are not initialized, they will contain whatever happened to be in memory. Since the memory comes from the pool, this will be either zero entity references or whatever where in a previously deallocated list.

Trait Implementations

impl<T> Clone for EntityList<T>

where T: Clone + EntityRef + ReservedValue,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for EntityList<T>

where T: Debug + EntityRef + ReservedValue,

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

Formats the value using the given formatter.

impl<T> Default for EntityList<T>

where T: EntityRef + ReservedValue,

Create an empty list.

fn default() -> EntityList<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for EntityList<T>

where T: EntityRef + ReservedValue,

fn deserialize<__D>( __deserializer: __D, ) -> Result<EntityList<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Hash for EntityList<T>

where T: Hash + EntityRef + ReservedValue,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for EntityList<T>

where T: PartialEq + EntityRef + ReservedValue,

fn eq(&self, other: &EntityList<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for EntityList<T>

where T: EntityRef + ReservedValue,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Copy for EntityList<T>

where T: Copy + EntityRef + ReservedValue,

impl<T> Eq for EntityList<T>

where T: Eq + EntityRef + ReservedValue,

impl<T> StructuralPartialEq for EntityList<T>

where T: EntityRef + ReservedValue,