Struct PhantomDeserData 

pub struct PhantomDeserData<T: ?Sized>(pub PhantomData<T>);

A type semantically equivalent to PhantomData, but whose type parameter is replaced with its associated deserialization type.

In some case, you might find yourself with a deep-copy type that has a type parameter T appearing both in a field and in a PhantomData. In this case, the type will not compile, as in its associated deserialization type T will be replaced by T::DeserType, but the PhantomData field will still contain T. To fix this issue, you can use PhantomDeserData instead.

Note that T must be sized.

Examples

This code will not compile:

use epserde::prelude::*;
#[derive(Epserde, Debug, PartialEq, Eq, Clone, Default)]
struct Data<T> {
    data: T,
    phantom: PhantomData<T>,
}

This code, instead, will compile:

use epserde::prelude::*;
#[derive(Epserde, Debug, PartialEq, Eq, Clone, Default)]
struct Data<T> {
    data: T,
    phantom: PhantomDeserData<T>,
}

Tuple Fields

0: PhantomData<T>

Implementations

impl<T: DeserializeInner> PhantomDeserData<T>

pub unsafe fn _deserialize_eps_inner_special<'a>( _backend: &mut SliceWithPos<'a>, ) -> Result<PhantomDeserData<T::DeserType<'a>>>

A custom deserialization method for PhantomDeserData that transmutes the inner type.

Safety

See DeserializeInner::_deserialize_eps_inner.

Trait Implementations

impl<T: ?Sized> AlignHash for PhantomDeserData<T>

fn align_hash(_hasher: &mut impl Hasher, _offset_of: &mut usize)

Accumulate alignment information in hasher assuming to be positioned at offset_of.

fn align_hash_val(&self, hasher: &mut impl Hasher, offset_of: &mut usize)

Call AlignHash::align_hash on a value.

impl<T: Clone + ?Sized> Clone for PhantomDeserData<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized> CopyType for PhantomDeserData<T>

type Copy = Zero

impl<T: Debug + ?Sized> Debug for PhantomDeserData<T>

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

Formats the value using the given formatter.

impl<T: Default + ?Sized> Default for PhantomDeserData<T>

fn default() -> PhantomDeserData<T>

Returns the “default value” for a type.

impl<T: DeserializeInner> DeserializeInner for PhantomDeserData<T>

type DeserType<'a> = PhantomDeserData<<T as DeserializeInner>::DeserType<'a>>

The deserialization type associated with this type. It can be retrieved conveniently with the alias DeserType.

unsafe fn _deserialize_full_inner( _backend: &mut impl ReadWithPos, ) -> Result<Self>

Safety

unsafe fn _deserialize_eps_inner<'a>( _backend: &mut SliceWithPos<'a>, ) -> Result<Self::DeserType<'a>>

Safety

impl<T: Hash + ?Sized> Hash for PhantomDeserData<T>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: ?Sized> MaxSizeOf for PhantomDeserData<T>

fn max_size_of() -> usize

impl<T: PartialEq + ?Sized> PartialEq for PhantomDeserData<T>

fn eq(&self, other: &PhantomDeserData<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<T: ?Sized> SerializeInner for PhantomDeserData<T>

const IS_ZERO_COPY: bool = true

Inner constant used by the derive macros to keep track recursively of whether the type satisfies the conditions for being zero-copy. It is checked at runtime against the trait implemented by the type, and if a ZeroCopy type has this constant set to false serialization will panic.

const ZERO_COPY_MISMATCH: bool = false

Inner constant used by the derive macros to keep track of whether all fields of a type are zero-copy but neither the attribute #[zero_copy] nor the attribute #[deep_copy] was specified. It is checked at runtime, and if it is true a warning will be issued, as the type could be zero-copy, which would be more efficient.

type SerType = PhantomDeserData<T>

This is the type that will be written in the header of the file, and thus the type that will be deserialized. In most cases it is Self, but in some cases, as for references to slices, it is customized.

unsafe fn _serialize_inner( &self, _backend: &mut impl WriteWithNames, ) -> Result<()>

Serialize this structure using the given backend.

impl<T: ?Sized + TypeHash> TypeHash for PhantomDeserData<T>

fn type_hash(hasher: &mut impl Hasher)

Accumulate type information in hasher.

fn type_hash_val(&self, hasher: &mut impl Hasher)

Call TypeHash::type_hash on a value.

impl<T: Copy + ?Sized> Copy for PhantomDeserData<T>

impl<T: Eq + ?Sized> Eq for PhantomDeserData<T>

impl<T: ?Sized> StructuralPartialEq for PhantomDeserData<T>