Struct LabelsStore

pub struct LabelsStore<A> {
    pub gap_cost: f64,
    pub gamma: f64,
    pub labels: A,
}

This struct is how the labels and their metadata are stored on disk.

Fields

gap_cost: f64

gamma: f64

labels: A

Trait Implementations

impl<A> AlignHash for LabelsStore<A>

where A: AlignHash,

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<A: Clone> Clone for LabelsStore<A>

fn clone(&self) -> LabelsStore<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> CopyType for LabelsStore<A>

type Copy = Deep

impl<A: Debug> Debug for LabelsStore<A>

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

Formats the value using the given formatter.

impl<A> DeserializeInner for LabelsStore<A>

where f64: DeserializeInner, A: DeserializeInner,

type DeserType<'epserde_desertype> = LabelsStore<<A as DeserializeInner>::DeserType<'epserde_desertype>>

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

fn _deserialize_full_inner( backend: &mut impl ReadWithPos, ) -> Result<Self, Error>

fn _deserialize_eps_inner<'deserialize_eps_inner_lifetime>( backend: &mut SliceWithPos<'deserialize_eps_inner_lifetime>, ) -> Result<Self::DeserType<'deserialize_eps_inner_lifetime>, Error>

impl<A> SerializeInner for LabelsStore<A>

where f64: SerializeInner, A: SerializeInner,

const IS_ZERO_COPY: bool

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

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 = LabelsStore<<A as SerializeInner>::SerType>

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.

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

Serialize this structure using the given backend.

impl<A> TypeHash for LabelsStore<A>

where A: TypeHash,

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.