Struct ArrayStorageSlx 

#[repr(transparent)]
pub struct ArrayStorageSlx<T, const R: usize, const C: usize>(pub [[T; R]; C]);

Silx array storage

Tuple Fields

0: [[T; R]; C]

Trait Implementations

impl<T, const R: usize, const C: usize> Archive for ArrayStorageSlx<T, R, C>

where T: Archive,

type Archived = ArrayStorageSlx<<T as Archive>::Archived, R, C>

The archived representation of this type.

type Resolver = <[[T; R]; C] as Archive>::Resolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl<T: Clone, const R: usize, const C: usize> Clone for ArrayStorageSlx<T, R, C>

fn clone(&self) -> ArrayStorageSlx<T, R, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const R: usize, const C: usize> Debug for ArrayStorageSlx<T, R, C>

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

Formats the value using the given formatter.

impl<'a, T, const R: usize, const C: usize> DerefArch<'a, ArrayStorageSlx<T, R, C>> for DerefMatrixSlx<T, ConstSlx<R>, ConstSlx<C>, ArchRefArrayStorageSlx<'a, T, R, C>>

where T: 'a + Archive<Archived = T> + HashedTypeDef,

fn deref_arch( arch: &'a ArchData<ArrayStorageSlx<T, R, C>>, ) -> Result<Self, String>

Convert slx archive to dereferencing

impl<'a, T, const R: usize, const C: usize> DerefMutArch<'a, ArrayStorageSlx<T, R, C>> for DerefMatrixSlx<T, ConstSlx<R>, ConstSlx<C>, ArchMutArrayStorageSlx<'a, T, R, C>>

where T: 'a + Unpin + Archive<Archived = T> + HashedTypeDef,

fn deref_mut_arch( arch: Pin<&'a mut ArchData<ArrayStorageSlx<T, R, C>>>, ) -> Result<Pin<Self>, String>

Convert slx archive to pinned mutable dereferencing

impl<D: Fallible + ?Sized, T, const R: usize, const C: usize> Deserialize<ArrayStorageSlx<T, R, C>, D> for Archived<ArrayStorageSlx<T, R, C>>

where T: Archive, [[Archived<T>; R]; C]: Deserialize<[[T; R]; C], D>,

fn deserialize( &self, deserializer: &mut D, ) -> Result<ArrayStorageSlx<T, R, C>, D::Error>

Deserializes using the given deserializer

impl<'a, T, const R: usize, const C: usize> From<&'a <ArrayStorageSlx<T, R, C> as Archive>::Archived> for ArchRefArrayStorageSlx<'a, T, R, C>

where T: Archive,

fn from(archived: &'a Archived<ArrayStorageSlx<T, R, C>>) -> Self

Converts to this type from the input type.

impl<'a, T, const R: usize, const C: usize> From<&'a <ArrayStorageSlx<T, R, C> as Archive>::Archived> for DerefMatrixSlx<T, ConstSlx<R>, ConstSlx<C>, ArchRefArrayStorageSlx<'a, T, R, C>>

where T: Archive,

fn from(archived: &'a Archived<ArrayStorageSlx<T, R, C>>) -> Self

Converts to this type from the input type.

impl<T, const R: usize, const C: usize> From<&ArrayStorageSlx<<T as Archive>::Archived, R, C>> for &Matrix<T, Const<R>, Const<C>, ArrayStorageSlx<Archived<T>, R, C>>

where T: Archive,

fn from(data: &ArrayStorageSlx<Archived<T>, R, C>) -> Self

Converts to this type from the input type.

impl<'a, T, const R: usize, const C: usize> From<&'a mut <ArrayStorageSlx<T, R, C> as Archive>::Archived> for ArchMutArrayStorageSlx<'a, T, R, C>

where T: Archive,

fn from(archived: &'a mut Archived<ArrayStorageSlx<T, R, C>>) -> Self

Converts to this type from the input type.

impl<'a, T, const R: usize, const C: usize> From<&'a mut <ArrayStorageSlx<T, R, C> as Archive>::Archived> for DerefMatrixSlx<T, ConstSlx<R>, ConstSlx<C>, ArchMutArrayStorageSlx<'a, T, R, C>>

where T: Archive,

fn from(archived: &'a mut Archived<ArrayStorageSlx<T, R, C>>) -> Self

Converts to this type from the input type.

impl<T, const R: usize, const C: usize> HashedTypeDef for ArrayStorageSlx<T, R, C>

where T: HashedTypeDef, (): HashedTypeDef,

const TYPE_HASH_NATIVE: u128

native hash computation

const TYPE_HASH_LE: u128 = _

hash encoded to little endianess

const TYPE_HASH_BE: u128 = _

hash encoded to big endianess

const UUID: Uuid = _

hash encoded to Uuid

impl<T: PartialEq, const R: usize, const C: usize> PartialEq for ArrayStorageSlx<T, R, C>

fn eq(&self, other: &ArrayStorageSlx<T, R, C>) -> 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<S: Fallible + ?Sized, T, const R: usize, const C: usize> Serialize<S> for ArrayStorageSlx<T, R, C>

where T: Archive, [[T; R]; C]: Serialize<S>,

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<T, const R: usize, const C: usize> SlxFrom<ArrayStorage<T, R, C>> for ArrayStorageSlx<T, R, C>

where T: Archive + HashedTypeDef,

fn slx_from(orig: ArrayStorage<T, R, C>) -> Self

Convert original data into slx data

impl<T, const R: usize, const C: usize> SlxFrom<Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>> for ArrayStorageSlx<T, R, C>

where T: Archive + HashedTypeDef,

fn slx_from(orig: SMatrix<T, R, C>) -> Self

Convert original data into slx data

impl<T, const R: usize, const C: usize> SlxInto<ArrayStorage<T, R, C>> for ArrayStorageSlx<T, R, C>

where T: Archive + HashedTypeDef,

fn unslx(self) -> ArrayStorage<T, R, C>

Convert slx data into original data

impl<T, const R: usize, const C: usize> SlxInto<Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>> for ArrayStorageSlx<T, R, C>

where T: Archive + HashedTypeDef,

fn unslx(self) -> SMatrix<T, R, C>

Convert slx data into original data

impl<T: Copy, const R: usize, const C: usize> Copy for ArrayStorageSlx<T, R, C>

impl<T: Clone, const R: usize, const C: usize> IsContiguous for ArrayStorageSlx<T, R, C>

impl<T: Clone, const R: usize, const C: usize> StorageSlx<Const<R>, Const<C>> for ArrayStorageSlx<T, R, C>

impl<T, const R: usize, const C: usize> StructuralPartialEq for ArrayStorageSlx<T, R, C>