Enum HashAlgorithm 

pub enum HashAlgorithm {
    XxHash3,
}

Hash algorithm selection

WDP specifies xxHash3 as the standard algorithm for error code hashing. xxHash3 is optimized for small inputs (15-30 byte error codes), making it ideal for WDP’s use case.

Note: This enum is kept for API compatibility but only xxHash3 is WDP-compliant.

Variants

XxHash3

xxHash3 - WDP-specified algorithm (default)

• Speed: ~30 GB/s
• Optimized for small inputs (perfect for error codes!)
• Security: NOT cryptographically secure (not needed for error codes)
• Cross-platform: C, Python, JS, Go, Java, Rust, etc.
• Standard: WDP Part 5 mandates xxHash3 with seed 0x000031762D706477

Implementations

impl HashAlgorithm

pub fn as_str(&self) -> &'static str

Get the algorithm name as a string

Examples found in repository

examples/global_config.rs (line 43)

fn main() {
    println!("🦆 WDP-Compliant Hash Configuration Example");
    println!("===========================================\n");

    // 1. Default behavior (WDP-compliant)
    println!("1. WDP-Compliant Default Configuration");
    println!("   Algorithm: xxHash3 (WDP-specified)");
    println!("   Seed: 0x{:016X} (WDP v1 seed)", WDP_SEED);
    let default_hash = compute_hash("E.AUTH.TOKEN.001");
    println!("   Hash: {}\n", default_hash);

    // 2. Load global configuration
    println!("2. Load Global Configuration");
    let global_config = load_global_config();
    println!("   Algorithm: {}", global_config.algorithm.as_str());
    println!("   Seed: 0x{:016X}", global_config.seed);

    let global_hash = compute_hash_with_config("E.AUTH.TOKEN.001", &global_config);
    println!("   Hash: {}\n", global_hash);

    // 3. Per-diagnostic seed overrides (for testing/isolation)
    println!("3. Custom Seed Override (for testing)");

    // Override seed (e.g., for tenant isolation in tests)
    let custom_seed_config = apply_overrides(&global_config, Some(0x12345678));
    let custom_seed_hash = compute_hash_with_config("E.AUTH.TOKEN.001", &custom_seed_config);
    println!("   Override seed to 0x12345678:");
    println!("   Hash: {}", custom_seed_hash);

    // No override (uses global)
    let no_override_config = apply_overrides(&global_config, None);
    let no_override_hash = compute_hash_with_config("E.AUTH.TOKEN.001", &no_override_config);
    println!("   No override (same as global):");
    println!("   Hash: {}\n", no_override_hash);

    // 4. Different error codes with same config
    println!("4. Multiple Error Codes (same config)");
    let codes = [
        "E.AUTH.TOKEN.001",
        "E.AUTH.SESSION.002",
        "E.DB.CONNECTION.003",
        "E.CACHE.MISS.004",
    ];

    for code in &codes {
        let hash = compute_hash_with_config(code, &global_config);
        println!("   {} → {}", code, hash);
    }

    println!("\n✅ WDP-compliant hashes ensure cross-platform consistency!");

    // 5. Configuration priority demonstration
    println!("\n5. Configuration Priority Order");
    println!("   1. Per-diagnostic seed override (highest)");
    println!("   2. Environment variable WADDLING_HASH_SEED");
    println!("   3. Cargo.toml hash_seed");
    println!("   4. WDP default seed (0x000031762D706477)\n");

    // Check if environment variable is set
    match option_env!("WADDLING_HASH_SEED") {
        Some(seed) => {
            println!("   📌 Environment variable detected:");
            println!("      WADDLING_HASH_SEED={}", seed);
        }
        None => {
            println!("   ℹ️  No environment variable set");
            println!("      Using WDP default seed");
        }
    }

    println!("\n🎯 WDP ensures cross-language compatibility!");
    println!("   Same error code produces same hash in:");
    println!("   - Rust, Python, JavaScript, Go, Java, C, etc.");
}

pub fn is_wdp_compliant(&self) -> bool

Check if algorithm is WDP-compliant

Returns true for xxHash3 (the only WDP-compliant algorithm).

pub fn is_cross_language(&self) -> bool

Check if algorithm is cross-language compatible

xxHash3 is supported in C, Python, JS, Go, Java, Rust, and more.

Trait Implementations

impl Clone for HashAlgorithm

fn clone(&self) -> HashAlgorithm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HashAlgorithm

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

Formats the value using the given formatter.

impl Default for HashAlgorithm

fn default() -> HashAlgorithm

Returns the “default value” for a type.

impl FromStr for HashAlgorithm

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse algorithm from string (case-insensitive)

Only xxHash3 is WDP-compliant.

Examples

use waddling_errors_hash::HashAlgorithm;
use std::str::FromStr;

assert_eq!(HashAlgorithm::from_str("xxHash3"), Ok(HashAlgorithm::XxHash3));
assert_eq!(HashAlgorithm::from_str("xxh3"), Ok(HashAlgorithm::XxHash3));
assert!(HashAlgorithm::from_str("unknown").is_err());

type Err = ParseHashAlgorithmError

The associated error which can be returned from parsing.

impl PartialEq for HashAlgorithm

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

impl Eq for HashAlgorithm

impl StructuralPartialEq for HashAlgorithm