Struct NetArray 

pub struct NetArray<T>
where
    T: Scalar,
{ /* private fields */ }

A wrapper type for using 0.8 rkyv APIs with nalgebra

Trait Implementations

impl<T> Archive for NetArray<T>

where T: Scalar, usize: Archive, Vec<T>: Archive,

type Archived = ArchivedNetArray<T>

The archived representation of this type.

type Resolver = NetArrayResolver<T>

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

fn resolve( &self, resolver: <NetArray<T> as Archive>::Resolver, out: Place<<NetArray<T> as Archive>::Archived>, )

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

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<T> Clone for NetArray<T>

where T: Clone + Scalar,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for NetArray<T>

where T: Debug + Scalar,

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

Formats the value using the given formatter.

impl<__D, T> Deserialize<NetArray<T>, __D> for <NetArray<T> as Archive>::Archived

where __D: Fallible + ?Sized, T: Scalar, usize: Archive, <usize as Archive>::Archived: Deserialize<usize, __D>, Vec<T>: Archive, <Vec<T> as Archive>::Archived: Deserialize<Vec<T>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<NetArray<T>, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<T> From<Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>> for NetArray<T>

where T: Scalar,

fn from(value: Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>) -> NetArray<T>

Converts to this type from the input type.

impl<T> PartialEq for NetArray<T>

where T: PartialEq + Scalar,

fn eq(&self, other: &NetArray<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<__S, T> Serialize<__S> for NetArray<T>

where __S: Fallible + ?Sized, T: Scalar, usize: Serialize<__S>, Vec<T>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<NetArray<T> as Archive>::Resolver, <__S as Fallible>::Error>

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

impl<T> Eq for NetArray<T>

where T: Eq + Scalar,

impl<T> StructuralPartialEq for NetArray<T>

where T: Scalar,