Struct BodyHash128 

pub struct BodyHash128 {
    pub high: u64,
    pub low: u64,
}

128-bit body hash for collision resistance

Using two xxh64 outputs with different seeds provides 128-bit security. This is sufficient to avoid birthday paradox collisions in codebases with millions of symbols.

Fields

high: u64

High 64 bits (computed with HASH_SEED_0)

low: u64

Low 64 bits (computed with HASH_SEED_1)

Implementations

impl BodyHash128

pub fn compute(content: &[u8]) -> Self

Compute deterministic 128-bit hash of normalized body content

Uses two xxh64 calls with different seeds to achieve 128-bit collision resistance. This follows the established pattern in sqry (see prewarm/store.rs:514).

Arguments

• content - Normalized body content bytes

Returns

A 128-bit hash value

pub fn as_u128(&self) -> u128

Convert to u128 for comparison and storage

pub fn from_u128(value: u128) -> Self

Create from u128 value

Trait Implementations

impl Clone for BodyHash128

fn clone(&self) -> BodyHash128

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BodyHash128

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

Formats the value using the given formatter.

impl Default for BodyHash128

fn default() -> BodyHash128

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BodyHash128

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for BodyHash128

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

Formats the value using the given formatter.

impl Hash for BodyHash128

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 PartialEq for BodyHash128

fn eq(&self, other: &BodyHash128) -> 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 Serialize for BodyHash128

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for BodyHash128

impl Eq for BodyHash128

impl StructuralPartialEq for BodyHash128