Rust类型哈希核心库type_hash_core使用指南

完整示例代码

下面是一个整合了基本用法和高级用法的完整示例：

use type_hash_core::{TypeHash, TypeInfo, TypeHasher};
use std::collections::HashMap;
use std::hash::Hasher;

// 1. 基本用法 - 获取类型哈希
#[derive(TypeHash)]
struct Person {
    id: u32,
    name: String,
    age: u8,
}

// 2. 运行时类型信息
#[derive(TypeHash, Debug)]
struct Coordinate {
    latitude: f64,
    longitude: f64,
}

// 3. 自定义哈希算法
struct MyHasher;

impl TypeHasher for MyHasher {
    fn hash<T: TypeHash>() -> u64 {
        // 简单实现：使用类型名的长度作为哈希值
        T::type_info().type_name().len() as u64
    }
}

#[derive(TypeHash)]
#[type_hasher(MyHasher)]
struct CustomHashType {
    data: Vec<u8>,
}

// 4. 类型注册系统扩展
trait Serializable: TypeHash {
    fn serialize(&self) -> String;
    fn deserialize(data: &str) -> Self;
}

struct SerializationRegistry {
    types: HashMap<u64, Box<dyn Fn(&str) -> Box<dyn std::any::Any>>>,
}

impl SerializationRegistry {
    fn new() -> Self {
        Self {
            types: HashMap::new(),
        }
    }
    
    fn register<T: Serializable + 'static>(&mut self) {
        let deserializer = |data: &str| {
            Box::new(T::deserialize(data)) as Box<dyn std::any::Any>
        };
        self.types.insert(T::type_hash(), Box::new(deserializer));
    }
    
    fn deserialize(&self, type_hash: u64, data: &str) -> Option<Box<dyn std::any::Any>> {
        self.types.get(&type_hash).map(|f| f(data))
    }
}

// 实现示例类型
#[derive(TypeHash)]
struct Product {
    id: String,
    price: f32,
}

impl Serializable for Product {
    fn serialize(&self) -> String {
        format!("{},{}", self.id, self.price)
    }
    
    fn deserialize(data: &str) -> Self {
        let parts: Vec<&str> = data.split(',').collect();
        Product {
            id: parts[0].to_string(),
            price: parts[1].parse().unwrap(),
        }
    }
}

fn main() {
    // 1. 基本类型哈希演示
    println!("Person type hash: {:x}", Person::type_hash());
    println!("Coordinate type hash: {:x}", Coordinate::type_hash());
    
    // 2. 运行时类型信息
    print_type_info::<Person>();
    print_type_info::<Coordinate>();
    
    // 3. 自定义哈希演示
    println!("CustomHashType hash: {:x}", CustomHashType::type_hash());
    
    // 4. 类型比较
    println!("Person == Coordinate: {}", is_same_type::<Person, Coordinate>());
    println!("i32 == i32: {}", is_same_type::<i32, i32>());
    
    // 5. 序列化注册系统演示
    let mut registry = SerializationRegistry::new();
    registry.register::<Product>();
    
    let product = Product {
        id: "123".to_string(),
        price: 99.99,
    };
    
    let serialized = product.serialize();
    if let Some(deserialized) = registry.deserialize(Product::type_hash(), &serialized) {
        if let Some(product) = deserialized.downcast_ref::<Product>() {
            println!("Deserialized product: {:?}", product);
        }
    }
}

// 辅助函数
fn print_type_info<T: TypeHash>() {
    let info = T::type_info();
    println!("\nType Info for {}", info.type_name());
    println!("Hash: {:x}", info.type_hash());
    println!("Is primitive: {}", info.is_primitive());
    println!("Type size: {}", std::mem::size_of::<T>());
}

fn is_same_type<T: TypeHash, U: TypeHash>() -> bool {
    T::type_hash() == U::type_hash()
}

示例说明

这个完整示例展示了：

1. 基本类型哈希功能 - 为Person和Coordinate结构体生成类型哈希
2. 运行时类型信息 - 通过print_type_info函数显示类型的详细信息
3. 自定义哈希算法 - 实现MyHasher并使用#[type_hasher]属性
4. 扩展的类型注册系统 - 实现了一个支持序列化/反序列化的类型注册系统
5. 类型比较功能 - 使用is_same_type比较不同类型

要运行这个示例，请确保在Cargo.toml中添加了type_hash_core依赖：

[dependencies]
type_hash_core = "0.3"

这个示例整合了库的主要功能，并展示了如何在实际应用中使用类型哈希来实现动态类型处理和序列化功能。