Struct MinHashSig 

#[repr(C)]
pub struct MinHashSig<const H: usize> {
    pub schema: u16,
    pub _pad: [u8; 6],
    pub hashes: [u64; H],
}

Available on crate feature minhash only.

MinHash signature with H hash slots.

Represented as a fixed-size, repr(C), bytemuck::Pod struct so callers can memory-map, persist, or zero-copy serialize collections of signatures.

Layout

offset 0..2   : u16 schema version (= [`SCHEMA_VERSION`])
offset 2..8   : 6 bytes padding (zeroed)
offset 8..    : H * u64 hash slots, little-endian

Total size: 8 + 8 * H bytes. 8-byte aligned.

Stability

The byte layout above is semver-frozen as of v0.1.0.

Fields

schema: u16

Schema version. Must equal SCHEMA_VERSION.

_pad: [u8; 6]

Padding to align hashes on an 8-byte boundary. Must be zero.

hashes: [u64; H]

The H min-hash slots.

Implementations

impl<const H: usize> MinHashSig<H>

pub const fn empty() -> Self

Construct an “all-maxima” signature.

Every slot is initialized to u64::MAX so a sketcher can collapse each slot toward the running minimum as tokens flow in. This is the documented initial state for both MinHashFingerprinter and MinHashStreaming.

Returns

MinHashSig<H> with schema = SCHEMA_VERSION, padding zeroed, and hashes = [u64::MAX; H].

Example

use txtfp::MinHashSig;

let s: MinHashSig<128> = MinHashSig::empty();
assert_eq!(s.schema, 1);
assert!(s.hashes.iter().all(|h| *h == u64::MAX));

pub const fn slot_count(&self) -> usize

Number of hash slots — equals the const generic H.

Example

use txtfp::MinHashSig;

assert_eq!(MinHashSig::<128>::empty().slot_count(), 128);
assert_eq!(MinHashSig::<64>::empty().slot_count(), 64);

pub fn as_bytes(&self) -> &[u8]

View the signature as a byte slice. Zero-copy.

Useful for hashing the signature itself (e.g. to build a content- addressed cache key) or for serializing to disk. The returned bytes match the on-disk layout documented at the type level.

Returns

A &[u8] of length 8 + 8 * H. Bytes are little-endian.

Example

use txtfp::MinHashSig;

let s: MinHashSig<8> = MinHashSig::empty();
let bytes = s.as_bytes();
assert_eq!(bytes.len(), 8 + 8 * 8);

// Zero-copy round-trip via bytemuck.
let s2: MinHashSig<8> = *bytemuck::from_bytes(bytes);
assert_eq!(s, s2);

Trait Implementations

impl<const H: usize> Clone for MinHashSig<H>

fn clone(&self) -> MinHashSig<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const H: usize> Debug for MinHashSig<H>

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

Formats the value using the given formatter.

impl<'de, const H: usize> Deserialize<'de> for MinHashSig<H>

fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<const H: usize> Hash for MinHashSig<H>

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<const H: usize> PartialEq for MinHashSig<H>

fn eq(&self, other: &MinHashSig<H>) -> 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<const H: usize> Serialize for MinHashSig<H>

fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<const H: usize> Zeroable for MinHashSig<H>

fn zeroed() -> Self

Calls zeroed.

impl<const H: usize> Copy for MinHashSig<H>

impl<const H: usize> Eq for MinHashSig<H>

impl<const H: usize> Pod for MinHashSig<H>

impl<const H: usize> StructuralPartialEq for MinHashSig<H>