Struct heron::rapier_plugin::rapier::crossbeam::atomic::AtomicCell [−]
A thread-safe mutable memory location.
This type is equivalent to Cell
, except it can also be shared among multiple threads.
Operations on AtomicCell
s use atomic instructions whenever possible, and synchronize using
global locks otherwise. You can call AtomicCell::<T>::is_lock_free()
to check whether
atomic instructions or locks will be used.
Atomic loads use the Acquire
ordering and atomic stores use the Release
ordering.
Implementations
impl<T> AtomicCell<T>
pub const fn new(val: T) -> AtomicCell<T>
Creates a new atomic cell initialized with val
.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7);
pub fn into_inner(self) -> T
Consumes the atomic and returns the contained value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7); let v = a.into_inner(); assert_eq!(v, 7);
pub const fn is_lock_free() -> bool
Returns true
if operations on values of this type are lock-free.
If the compiler or the platform doesn't support the necessary atomic instructions,
AtomicCell<T>
will use global locks for every potentially concurrent atomic operation.
Examples
use crossbeam_utils::atomic::AtomicCell; // This type is internally represented as `AtomicUsize` so we can just use atomic // operations provided by it. assert_eq!(AtomicCell::<usize>::is_lock_free(), true); // A wrapper struct around `isize`. struct Foo { bar: isize, } // `AtomicCell<Foo>` will be internally represented as `AtomicIsize`. assert_eq!(AtomicCell::<Foo>::is_lock_free(), true); // Operations on zero-sized types are always lock-free. assert_eq!(AtomicCell::<()>::is_lock_free(), true); // Very large types cannot be represented as any of the standard atomic types, so atomic // operations on them will have to use global locks for synchronization. assert_eq!(AtomicCell::<[u8; 1000]>::is_lock_free(), false);
pub fn store(&self, val: T)
Stores val
into the atomic cell.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7); assert_eq!(a.load(), 7); a.store(8); assert_eq!(a.load(), 8);
pub fn swap(&self, val: T) -> T
Stores val
into the atomic cell and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7); assert_eq!(a.load(), 7); assert_eq!(a.swap(8), 7); assert_eq!(a.load(), 8);
impl<T> AtomicCell<T> where
T: ?Sized,
T: ?Sized,
pub fn as_ptr(&self) -> *mut T
Returns a raw pointer to the underlying data in this atomic cell.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(5); let ptr = a.as_ptr();
impl<T> AtomicCell<T> where
T: Default,
T: Default,
pub fn take(&self) -> T
Takes the value of the atomic cell, leaving Default::default()
in its place.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(5); let five = a.take(); assert_eq!(five, 5); assert_eq!(a.into_inner(), 0);
impl<T> AtomicCell<T> where
T: Copy,
T: Copy,
pub fn load(&self) -> T
Loads a value from the atomic cell.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7); assert_eq!(a.load(), 7);
impl<T> AtomicCell<T> where
T: Eq + Copy,
T: Eq + Copy,
pub fn compare_and_swap(&self, current: T, new: T) -> T
If the current value equals current
, stores new
into the atomic cell.
The return value is always the previous value. If it is equal to current
, then the value
was updated.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(1); assert_eq!(a.compare_and_swap(2, 3), 1); assert_eq!(a.load(), 1); assert_eq!(a.compare_and_swap(1, 2), 1); assert_eq!(a.load(), 2);
pub fn compare_exchange(&self, current: T, new: T) -> Result<T, T>
If the current value equals current
, stores new
into the atomic cell.
The return value is a result indicating whether the new value was written and containing
the previous value. On success this value is guaranteed to be equal to current
.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(1); assert_eq!(a.compare_exchange(2, 3), Err(1)); assert_eq!(a.load(), 1); assert_eq!(a.compare_exchange(1, 2), Ok(1)); assert_eq!(a.load(), 2);
impl AtomicCell<bool>
pub fn fetch_and(&self, val: bool) -> bool
Applies logical "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(true); assert_eq!(a.fetch_and(true), true); assert_eq!(a.load(), true); assert_eq!(a.fetch_and(false), true); assert_eq!(a.load(), false);
pub fn fetch_or(&self, val: bool) -> bool
Applies logical "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(false); assert_eq!(a.fetch_or(false), false); assert_eq!(a.load(), false); assert_eq!(a.fetch_or(true), false); assert_eq!(a.load(), true);
pub fn fetch_xor(&self, val: bool) -> bool
Applies logical "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(true); assert_eq!(a.fetch_xor(false), true); assert_eq!(a.load(), true); assert_eq!(a.fetch_xor(true), true); assert_eq!(a.load(), false);
impl AtomicCell<u8>
pub fn fetch_add(&self, val: u8) -> u8
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u8); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: u8) -> u8
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u8); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: u8) -> u8
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u8); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: u8) -> u8
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u8); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: u8) -> u8
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u8); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
impl AtomicCell<i8>
pub fn fetch_add(&self, val: i8) -> i8
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i8); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: i8) -> i8
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i8); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: i8) -> i8
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i8); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: i8) -> i8
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i8); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: i8) -> i8
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i8); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
impl AtomicCell<u16>
pub fn fetch_add(&self, val: u16) -> u16
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u16); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: u16) -> u16
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u16); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: u16) -> u16
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u16); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: u16) -> u16
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u16); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: u16) -> u16
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u16); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
impl AtomicCell<i16>
pub fn fetch_add(&self, val: i16) -> i16
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i16); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: i16) -> i16
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i16); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: i16) -> i16
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i16); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: i16) -> i16
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i16); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: i16) -> i16
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i16); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
impl AtomicCell<u32>
pub fn fetch_add(&self, val: u32) -> u32
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u32); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: u32) -> u32
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u32); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: u32) -> u32
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u32); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: u32) -> u32
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u32); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: u32) -> u32
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u32); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
impl AtomicCell<i32>
pub fn fetch_add(&self, val: i32) -> i32
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i32); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: i32) -> i32
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i32); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: i32) -> i32
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i32); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: i32) -> i32
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i32); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: i32) -> i32
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i32); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
impl AtomicCell<u64>
pub fn fetch_add(&self, val: u64) -> u64
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u64); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: u64) -> u64
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u64); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: u64) -> u64
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u64); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: u64) -> u64
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u64); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: u64) -> u64
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7u64); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
impl AtomicCell<i64>
pub fn fetch_add(&self, val: i64) -> i64
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i64); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: i64) -> i64
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i64); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: i64) -> i64
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i64); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: i64) -> i64
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i64); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: i64) -> i64
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7i64); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
impl AtomicCell<usize>
pub fn fetch_add(&self, val: usize) -> usize
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7usize); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: usize) -> usize
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7usize); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: usize) -> usize
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7usize); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: usize) -> usize
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7usize); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: usize) -> usize
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7usize); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
impl AtomicCell<isize>
pub fn fetch_add(&self, val: isize) -> isize
Increments the current value by val
and returns the previous value.
The addition wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7isize); assert_eq!(a.fetch_add(3), 7); assert_eq!(a.load(), 10);
pub fn fetch_sub(&self, val: isize) -> isize
Decrements the current value by val
and returns the previous value.
The subtraction wraps on overflow.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7isize); assert_eq!(a.fetch_sub(3), 7); assert_eq!(a.load(), 4);
pub fn fetch_and(&self, val: isize) -> isize
Applies bitwise "and" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7isize); assert_eq!(a.fetch_and(3), 7); assert_eq!(a.load(), 3);
pub fn fetch_or(&self, val: isize) -> isize
Applies bitwise "or" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7isize); assert_eq!(a.fetch_or(16), 7); assert_eq!(a.load(), 23);
pub fn fetch_xor(&self, val: isize) -> isize
Applies bitwise "xor" to the current value and returns the previous value.
Examples
use crossbeam_utils::atomic::AtomicCell; let a = AtomicCell::new(7isize); assert_eq!(a.fetch_xor(2), 7); assert_eq!(a.load(), 5);
Trait Implementations
impl<T> Debug for AtomicCell<T> where
T: Copy + Debug,
T: Copy + Debug,
impl<T> Default for AtomicCell<T> where
T: Default,
T: Default,
pub fn default() -> AtomicCell<T>
impl<T> From<T> for AtomicCell<T>
pub fn from(val: T) -> AtomicCell<T>
impl<T> RefUnwindSafe for AtomicCell<T>
impl<T> Send for AtomicCell<T> where
T: Send,
T: Send,
impl<T> Sync for AtomicCell<T> where
T: Send,
T: Send,
impl<T> UnwindSafe for AtomicCell<T>
Auto Trait Implementations
impl<T: ?Sized> Unpin for AtomicCell<T> where
T: Unpin,
[src]
T: Unpin,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Any for T where
T: Any,
T: Any,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Component for T where
T: 'static + Send + Sync,
T: 'static + Send + Sync,
impl<T> Downcast for T where
T: Any,
T: Any,
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn as_any(&self) -> &(dyn Any + 'static)
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
impl<T> DowncastSync for T where
T: Send + Sync + Any,
T: Send + Sync + Any,
impl<T> From<!> for T
[src]
impl<T> From<T> for T
[src]
impl<T> FromResources for T where
T: Default,
T: Default,
pub fn from_resources(_resources: &Resources) -> T
impl<T> Instrument for T
[src]
pub fn instrument(self, span: Span) -> Instrumented<Self>
[src]
pub fn in_current_span(self) -> Instrumented<Self>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pointable for T
pub const ALIGN: usize
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
pub unsafe fn drop(ptr: usize)
impl<T> Resource for T where
T: 'static + Send + Sync,
T: 'static + Send + Sync,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
SS: SubsetOf<SP>,
pub fn to_subset(&self) -> Option<SS>
pub fn is_in_subset(&self) -> bool
pub fn to_subset_unchecked(&self) -> SS
pub fn from_subset(element: &SS) -> SP
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,