相关疑难解决方法(0)

我的类型A可以包含任何实现的类型,但是可以trait Trait序列化,尽管实现特征的类型Trait可能不是.在我的情况下,它不能 - 它是一个私人非对称密钥:

extern crate serde;
#[macro_use]
extern crate serde_derive;

use serde::de::DeserializeOwned;
use serde::Serialize;

trait Trait {
    type SerialisableType: Clone + Serialize + DeserializeOwned;

    fn inner(&self) -> &Self::SerialisableType;
}

#[derive(Serialize, Deserialize)]
enum A<T: Trait> {
    Variant0(B<T>), // *** NOTE: Compiles if this is commented ***
    Variant1(T::SerialisableType),
}

#[derive(Serialize, Deserialize)]
struct B<T: Trait> {
    inner: T::SerialisableType,
}

// ==============================================

struct NonSerialisable {
    serialisable: Serialisable,
}

impl Trait for NonSerialisable {
    type SerialisableType = Serialisable; …

我正在尝试编写一个派生的结构，serde::Deserialize但它也有一个应该派生的字段serde::Deserialize：

extern crate serde;
#[macro_use]
extern crate serde_derive;

use serde::{Deserialize, Serialize};

#[derive(PartialEq, Serialize, Deserialize)]
pub struct Record<'a, T>
where
    T: 'a + Serialize + Deserialize<'a>,
{
    id: &'a str,
    created_at: &'a str,
    created_by: Option<&'a str>,
    last_updated_at: Option<&'a str>,
    object: &'a T,
}

impl<'a, T> Record<'a, T>
where
    T: 'a + Serialize + Deserialize<'a>,
{
    pub fn new(
        id: &'a str,
        created_at: &'a str,
        created_by: Option<&'a str>,
        last_updated_at: Option<&'a str>,
        object: &'a T,
    ) -> Self { …

我正在尝试使用泛型从文件中反序列化结构，以便与 Swagger 生成的 API 一起使用。所以我把这个几乎可以工作，但我无法从“Owned”指针解压外部 Struct 对象，正如你在测试中看到的那样。

这可能是错误的策略，但问题是我有各种 yaml 文件，我想读入并反序列化暗示正确的结构来反序列化。我不想为每个 Struct 实现一个“readfile”函数，因为有很多。所以我试图让这个通用库工作，它应该反序列化为正确的结构，并与 Swagger API 一起使用。

这是非常接近的工作，但我似乎无法解开的Outer<ExternalStructA>逼到了ExternalStructA。

Owned(ExternalStructA { x: 1, y: 2 })
Owned(ExternalStructB { a: 1, b: 2 })

lib.rs：

#[cfg(test)]
mod tests {
    use crate::generics_yaml_deserializer::Outer;
    use serde::{de, Deserialize, Deserializer, Serialize, Serializer};

    #[derive(Debug, Serialize, Deserialize)]
    pub struct ExternalStructA {
        x: u32,
        y: u32,
    }

    #[derive(Debug, Serialize, Deserialize)]
    pub struct ExternalStructB {
        a: u64,
        b: u64,
    }

    #[test]
    fn deserialize() {
        let a = r#"--- …