pub trait CopyType: Sized {
type Copy: CopySelector;
}Expand description
Marker trait for data specifying whether it is zero-copy or deep-copy.
The trait comes in two flavors: CopySelector<Type=Zero> and
CopySelector<Type=Deep>. To each of these flavors corresponds two
dependent traits, ZeroCopy (which requires implementing MaxSizeOf)
and DeepCopy, which are automatically
implemented.
use epserde::traits::*;
struct MyType {}
impl CopyType for MyType {
type Copy = Deep;
}
// Now MyType implements DeepCopyYou should not implement this trait manually, but rather use the provided derive macro.
We use this trait to implement a different behavior for ZeroCopy and DeepCopy types,
in particular on arrays, vectors, and boxed slices,
working around the bug that prevents the compiler from understanding that implementations
for the two flavors of CopySelector are mutually
exclusive.
For an array of elements of type T to be zero-copy serializable and
deserializable, T must implement CopySelector<Type=Zero>. The conditions for this marker trait are that
T is a copy type, that it has a fixed memory layout,
and that it does not contain any reference (in particular, that it has 'static lifetime).
If this happen vectors of T or boxed slices of T can be ε-copy deserialized
using a reference to a slice of T.
You can make zero-copy your own types, but you must ensure that they do not
contain references and that they have a fixed memory layout; for structures, this requires
repr(C). ε-serde will track these conditions at compile time and check them at
runtime: in case of failure, serialization will panic.
Since we cannot use negative trait bounds, every type that is used as a parameter of
an array, vector or boxed slice must implement either CopySelector<Type=Zero>
or CopySelector<Type=Deep>. In the latter
case, slices will be deserialized element by element, and the result will be a fully
deserialized vector or boxed
slice. If you do not implement either of these traits, the type will not be serializable inside
vectors or boxed slices but error messages will be very unhelpful due to the
contrived way we have to implement mutually exclusive types.
If you use the provided derive macros all this logic will be hidden from you. You’ll
just have to add #[zero_copy] to your structures (if you want them to be zero-copy)
and ε-serde will do the rest.