Rust Base64标签化编解码宏库tagged-base64-macros的使用，支持类型安全的高效数据转换

安装

在项目目录中运行以下Cargo命令：

cargo add tagged-base64-macros

或者在Cargo.toml中添加以下行：

tagged-base64-macros = "0.4.0"

使用示例

这是一个完整的示例demo，展示如何使用tagged-base64-macros进行类型安全的Base64编码和解码：

use tagged_base64_macros::{tagged_base64_encode, tagged_base64_decode};

// 定义自定义类型
#[derive(Debug, PartialEq)]
struct MyData {
    id: u32,
    name: String,
}

// 为自定义类型实现编码和解码
impl MyData {
    fn encode(&self) -> String {
        format!("{}:{}", self.id, self.name)
    }
    
    fn decode(s: &str) -> Result<Self, String> {
        let parts: Vec<&str> = s.splitn(2, ':').collect();
        if parts.len() != 2 {
            return Err("Invalid format".to_string());
        }
        let id = parts[0].parse().map_err(|_| "Invalid ID".to_string())?;
        Ok(MyData {
            id,
            name: parts[1].to_string(),
        })
    }
}

// 使用宏进行编码
#[tagged_base64_encode]
fn encode_my_data(data: &MyData) -> String {
    data.encode()
}

// 使用宏进行解码
#[tagged_base64_decode]
fn decode_my_data(encoded: &str) -> Result<MyData, String> {
    MyData::decode(encoded)
}

fn main() {
    let data = MyData {
        id: 42,
        name: "Test".to_string(),
    };
    
    // 编码
    let encoded = encode_my_data(&data);
    println!("Encoded: {}", encoded);
    
    // 解码
    let decoded = decode_my_data(&encoded).unwrap();
    println!("Decoded: {:?}", decoded);
    
    assert_eq!(data, decoded);
}

完整示例代码

use tagged_base64_macros::{tagged_base64_encode, tagged_base64_decode};

// 自定义数据结构
#[derive(Debug, PartialEq)]
struct UserProfile {
    user_id: u64,
    username: String,
    is_admin: bool,
}

// 实现自定义编解码逻辑
impl UserProfile {
    // 将结构体编码为字符串
    fn to_string(&self) -> String {
        format!("{}|{}|{}", self.user_id, self.username, self.is_admin)
    }
    
    // 从字符串解码为结构体
    fn from_str(s: &str) -> Result<Self, String> {
        let parts: Vec<&str> = s.split('|').collect();
        if parts.len() != 3 {
            return Err("格式错误: 需要3个部分".to_string());
        }
        
        let user_id = parts[0].parse().map_err(|_| "无效的用户ID".to_string())?;
        let is_admin = parts[2].parse().map_err(|_| "无效的管理员标志".to_string())?;
        
        Ok(UserProfile {
            user_id,
            username: parts[1].to_string(),
            is_admin,
        })
    }
}

// 使用宏定义Base64编码函数
#[tagged_base64_encode]
fn encode_profile(profile: &UserProfile) -> String {
    profile.to_string()
}

// 使用宏定义Base64解码函数
#[tagged_base64_decode]
fn decode_profile(encoded: &str) -> Result<UserProfile, String> {
    UserProfile::from_str(encoded)
}

fn main() {
    // 创建示例数据
    let profile = UserProfile {
        user_id: 12345,
        username: "rustacean".to_string(),
        is_admin: true,
    };
    
    // 编码测试
    let encoded = encode_profile(&profile);
    println!("编码结果: {}", encoded);
    
    // 解码测试
    match decode_profile(&encoded) {
        Ok(decoded) => {
            println!("解码结果: {:?}", decoded);
            assert_eq!(profile, decoded);
        }
        Err(e) => eprintln!("解码错误: {}", e),
    }
}

特性

1. 类型安全：通过宏系统确保编码和解码过程的类型安全
2. 高效转换：优化的Base64编解码实现
3. 自定义支持：可以轻松为自定义类型实现编解码
4. 错误处理：提供清晰的错误处理机制

许可证

MIT License