我可以为单个结构以不同的方式多次实现相同的特征吗？

Question

我想根据情况以两种不同的方式序列化结构，但我面临一个问题：以我目前的知识，我只能以一种方式序列化结构。

这是我的代码#[derive(Serialize)]（自动派生）

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct TransactionContent {
    sender_addr: Vec<u8>,
    sender_pubkey: Vec<u8>,
    receiver_addr: Vec<u8>,
    amount: u32,
    timestamp: i64
}

我使用的bincode::serialize序列化我的结构，使之成为Vec<u8>我也想给结构存储在一个JSON文件。当序列化为 JSON 时，我想以我自己的方式序列化它，比如为Vec<u8>字段返回一个 base58 字符串。

这是我自己的实现：

impl Serialize for TransactionContent {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where S: Serializer
    {
        let mut state = serializer.serialize_struct("TransactionContent", 5)?;
        state.serialize_field("sender_addr", &self.sender_addr.to_base58())?;
        state.serialize_field("sender_pubkey", &self.sender_pubkey.to_base58())?;
        state.serialize_field("receiver_addr", &self.receiver_addr.to_base58())?;
        state.serialize_field("amount", &self.amount)?;
        state.serialize_field("timestamp", &self.timestamp)?;
        state.end()
    }
}

我不能同时使用上面的代码。如果我使用自动派生，则第二个Impl是不可能的。如果我使用第二个，该bincode::serialize功能将工作，但不是我想要的（我想使用Vec<u8>它）

有没有办法可以同时使用两者Impl？例如条件之类的东西Impl？

Answer 1

不，您不能为单一类型以多种方式多次实现相同的特征。

作为在评论中提到，你可以创建一个NEWTYPE一个包装完整的数据和执行所要求的特质：

use serde::{ser::SerializeStruct, Serialize, Serializer}; // 1.0.117
use serde_json; // 1.0.59

#[derive(Debug, Serialize)]
struct Real {
    data: Vec<u8>,
}

struct AsJson<'a>(&'a Real);

impl<'a> Serialize for AsJson<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("Thing", 1)?;
        state.serialize_field("data", b"this is some data")?;
        state.end()
    }
}

fn main() {
    let r = Real {
        data: vec![1, 2, 3, 4],
    };
    println!("{:?}", serde_json::to_string(&r));
    println!("{:?}", serde_json::to_string(&AsJson(&r)));
}

如果你控制了特质

您可以向特征添加一个泛型参数并为同一类型多次实现它：

trait Example<T> {}

struct Style1;
struct Style2;

impl Example<Style1> for i32 {}
impl Example<Style2> for i32 {}

但这并非没有缺点。

也可以看看：

• 什么时候使用关联类型与泛型类型合适？