99 lines
2.0 KiB
Rust
99 lines
2.0 KiB
Rust
use hash2::Hash2;
|
|
use std::collections::hash_map::DefaultHasher;
|
|
use std::hash::Hasher;
|
|
|
|
// Basic struct with derive
|
|
#[derive(Hash2)]
|
|
pub struct User {
|
|
pub id: u64,
|
|
pub name: String,
|
|
pub age: u8,
|
|
}
|
|
|
|
// Struct with generics
|
|
#[derive(Hash2)]
|
|
pub struct Container<T> {
|
|
pub value: T,
|
|
pub count: usize,
|
|
}
|
|
|
|
// Struct with lifetimes
|
|
#[derive(Hash2)]
|
|
pub struct Borrowed<'a> {
|
|
pub data: &'a str,
|
|
pub id: u64,
|
|
}
|
|
|
|
// Struct with both generics and lifetimes
|
|
#[derive(Hash2)]
|
|
pub struct Complex<'a, T> {
|
|
pub owned: T,
|
|
pub borrowed: &'a str,
|
|
}
|
|
|
|
// Example with PhantomData (like the original Test struct)
|
|
#[derive(Hash2)]
|
|
pub struct Test<'a> {
|
|
pub test: f32,
|
|
pub test2: u64,
|
|
pub _ignored: std::marker::PhantomData<&'a ()>,
|
|
}
|
|
|
|
// Enum example
|
|
#[derive(Hash2)]
|
|
pub enum Status {
|
|
Active,
|
|
Inactive,
|
|
Pending { since: u64 },
|
|
}
|
|
|
|
fn compute_hash<T: Hash2>(value: &T) -> u64 {
|
|
let mut hasher = DefaultHasher::new();
|
|
value.hash(&mut hasher);
|
|
hasher.finish()
|
|
}
|
|
|
|
fn main() {
|
|
// Basic struct
|
|
let user = User {
|
|
id: 42,
|
|
name: "Alice".to_string(),
|
|
age: 30,
|
|
};
|
|
println!("User hash: {}", compute_hash(&user));
|
|
|
|
// Generic struct
|
|
let container = Container {
|
|
value: 100u32,
|
|
count: 5,
|
|
};
|
|
println!("Container hash: {}", compute_hash(&container));
|
|
|
|
// Borrowed struct
|
|
let text = String::from("Hello");
|
|
let borrowed = Borrowed {
|
|
data: &text,
|
|
id: 1,
|
|
};
|
|
println!("Borrowed hash: {}", compute_hash(&borrowed));
|
|
|
|
// Complex struct
|
|
let complex = Complex {
|
|
owned: vec![1, 2, 3],
|
|
borrowed: &text,
|
|
};
|
|
println!("Complex hash: {}", compute_hash(&complex));
|
|
|
|
// Test struct (original example)
|
|
let test = Test {
|
|
test: 3.14,
|
|
test2: 999,
|
|
_ignored: std::marker::PhantomData,
|
|
};
|
|
println!("Test hash: {}", compute_hash(&test));
|
|
|
|
// Enum
|
|
let status = Status::Pending { since: 12345 };
|
|
println!("Status hash: {}", compute_hash(&status));
|
|
}
|