Struct bvh_anim::JointName

pub struct JointName(pub SmallVec<[u8; 24]>);

Wrapper struct for the Joint name type.

Methods from Deref<Target = SmallVec<[u8; 24]>>

pub unsafe fn set_len(&mut self, new_len: usize)

Sets the length of a vector.

This will explicitly set the size of the vector, without actually modifying its buffers, so it is up to the caller to ensure that the vector is actually the specified size.

pub fn inline_size(&self) -> usize

The maximum number of elements this vector can hold inline

pub fn len(&self) -> usize

The number of elements stored in the vector

pub fn is_empty(&self) -> bool

Returns true if the vector is empty

pub fn capacity(&self) -> usize

The number of items the vector can hold without reallocating

pub fn spilled(&self) -> bool

Returns true if the data has spilled into a separate heap-allocated buffer.

pub fn drain(&mut self) -> Drain<<A as Array>::Item>

Empty the vector and return an iterator over its former contents.

pub fn push(&mut self, value: <A as Array>::Item)

Append an item to the vector.

pub fn pop(&mut self) -> Option<<A as Array>::Item>

Remove an item from the end of the vector and return it, or None if empty.

pub fn grow(&mut self, new_cap: usize)

Re-allocate to set the capacity to max(new_cap, inline_size()).

Panics if new_cap is less than the vector's length.

pub fn reserve(&mut self, additional: usize)

Reserve capacity for additional more elements to be inserted.

May reserve more space to avoid frequent reallocations.

If the new capacity would overflow usize then it will be set to usize::max_value() instead. (This means that inserting additional new elements is not guaranteed to be possible after calling this function.)

pub fn reserve_exact(&mut self, additional: usize)

Reserve the minimum capacity for additional more elements to be inserted.

Panics if the new capacity overflows usize.

pub fn shrink_to_fit(&mut self)

Shrink the capacity of the vector as much as possible.

When possible, this will move data from an external heap buffer to the vector's inline storage.

pub fn truncate(&mut self, len: usize)

Shorten the vector, keeping the first len elements and dropping the rest.

If len is greater than or equal to the vector's current length, this has no effect.

This does not re-allocate. If you want the vector's capacity to shrink, call shrink_to_fit after truncating.

pub fn as_slice(&self) -> &[<A as Array>::Item]

Extracts a slice containing the entire vector.

Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [<A as Array>::Item]

Extracts a mutable slice of the entire vector.

Equivalent to &mut s[..].

pub fn swap_remove(&mut self, index: usize) -> <A as Array>::Item

Remove the element at position index, replacing it with the last element.

This does not preserve ordering, but is O(1).

Panics if index is out of bounds.

pub fn clear(&mut self)

Remove all elements from the vector.

pub fn remove(&mut self, index: usize) -> <A as Array>::Item

Remove and return the element at position index, shifting all elements after it to the left.

Panics if index is out of bounds.

pub fn insert(&mut self, index: usize, element: <A as Array>::Item)

Insert an element at position index, shifting all elements after it to the right.

Panics if index is out of bounds.

pub fn insert_many<I>(&mut self, index: usize, iterable: I) where
    I: IntoIterator<Item = <A as Array>::Item>, 

Insert multiple elements at position index, shifting all following elements toward the back.

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(&mut <A as Array>::Item) -> bool, 

Retains only the elements specified by the predicate.

In other words, remove all elements e such that f(&e) returns false. This method operates in place and preserves the order of the retained elements.

pub fn dedup(&mut self) where
    <A as Array>::Item: PartialEq<<A as Array>::Item>, 

Removes consecutive duplicate elements.

pub fn dedup_by<F>(&mut self, same_bucket: F) where
    F: FnMut(&mut <A as Array>::Item, &mut <A as Array>::Item) -> bool, 

Removes consecutive duplicate elements using the given equality relation.

pub fn dedup_by_key<F, K>(&mut self, key: F) where
    F: FnMut(&mut <A as Array>::Item) -> K,
    K: PartialEq<K>, 

Removes consecutive elements that map to the same key.

pub fn insert_from_slice(&mut self, index: usize, slice: &[<A as Array>::Item])

Copy elements from a slice into the vector at position index, shifting any following elements toward the back.

For slices of Copy types, this is more efficient than insert.

pub fn extend_from_slice(&mut self, slice: &[<A as Array>::Item])

Copy elements from a slice and append them to the vector.

For slices of Copy types, this is more efficient than extend.

pub fn resize(&mut self, len: usize, value: <A as Array>::Item)

Resizes the vector so that its length is equal to len.

If len is less than the current length, the vector simply truncated.

If len is greater than the current length, value is appended to the vector until its length equals len.

Trait Implementations

impl AsMut<BStr> for JointName

fn as_mut(&mut self) -> &mut BStr

Performs the conversion.

impl AsMut<[u8]> for JointName

fn as_mut(&mut self) -> &mut [u8]

Performs the conversion.

impl<B: AsRef<[u8]>> PartialEq<B> for JointName

fn eq(&self, rhs: &B) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl AsRef<BStr> for JointName

fn as_ref(&self) -> &BStr

Performs the conversion.

impl AsRef<[u8]> for JointName

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl Default for JointName

fn default() -> JointName

Returns the "default value" for a type.

impl Clone for JointName

fn clone(&self) -> JointName

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Ord for JointName

fn cmp(&self, other: &JointName) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl From<CString> for JointName

fn from(s: CString) -> Self

Performs the conversion.

impl<'_> From<&'_ CStr> for JointName

fn from(s: &CStr) -> Self

Performs the conversion.

impl From<Vec<u8>> for JointName

fn from(s: Vec<u8>) -> Self

Performs the conversion.

impl<'_> From<&'_ [u8]> for JointName

fn from(s: &[u8]) -> Self

Performs the conversion.

impl From<String> for JointName

fn from(b: String) -> Self

Performs the conversion.

impl<'_> From<&'_ str> for JointName

fn from(b: &str) -> Self

Performs the conversion.

impl From<BString> for JointName

fn from(b: BString) -> Self

Performs the conversion.

impl<'_> From<&'_ BStr> for JointName

fn from(b: &BStr) -> Self

Performs the conversion.

impl From<SmallVec<[u8; 24]>> for JointName

fn from(v: SmallVec<[u8; 24]>) -> Self

Performs the conversion.

impl From<JointName> for SmallVec<[u8; 24]>

fn from(j: JointName) -> Self

Performs the conversion.

impl Eq for JointName

impl<B: AsRef<[u8]>> PartialOrd<B> for JointName

fn partial_cmp(&self, rhs: &B) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl DerefMut for JointName

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Deref for JointName

type Target = SmallVec<[u8; 24]>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for JointName

fn fmt(&self, fmtr: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Debug for JointName

fn fmt(&self, fmtr: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Hash for JointName

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].