Json 使用Serde反序列化跳过序列中的无效元素

使用Serde，我希望通过保留有效元素并跳过无效元素来反序列化元素序列

我有以下有效载荷：

{
    "nhits": 30,
    "parameters": {
        "dataset": "occupation-parkings-temps-reel",
        "timezone": "UTC",
        "rows": 50,
        "start": 0,
        "format": "json",
        "facet": [
            "etat_descriptif"
        ]
    },
    "records": [
        {
            "datasetid": "occupation-parkings-temps-reel",
            "recordid": "1436c55a76fc7910b5a0336eb74cc0957870a8fd",
            "fields": {
                "nom_parking": "P1 Esplanade - Centre commercial",
                "etat": 1,
                "ident": 27,
                "infousager": "220",
                "idsurfs": "1703_DEP_27",
                "libre": 229,
                "total": 251,
                "etat_descriptif": "Ouvert"
            },
            "record_timestamp": "2020-12-20T12:51:00.704000+00:00"
        },
        {
            "datasetid": "occupation-parkings-temps-reel",
            "recordid": "2b15689c04478fcad8c964a5d9f3c0148eb70126",
            "fields": {
                "etat": 1,
                "ident": 30,
                "infousager": "LIBRE",
                "libre": 719,
                "total": 719,
                "etat_descriptif": "Ouvert"
            },
            "record_timestamp": "2020-12-20T12:51:00.704000+00:00"
        }
    ],
    "facet_groups": [
        {
            "facets": [
                {
                    "count": 28,
                    "path": "Ouvert",
                    "state": "displayed",
                    "name": "Ouvert"
                },
                {
                    "count": 1,
                    "path": "Ferm\u00e9",
                    "state": "displayed",
                    "name": "Ferm\u00e9"
                },
                {
                    "count": 1,
                    "path": "frequentation temps reel indisponible",
                    "state": "displayed",
                    "name": "frequentation temps reel indisponible"
                }
            ],
            "name": "etat_descriptif"
        }
    ]
}

我有一个不同的对应结构：

/// The container for the API response
#[derive(Debug, Deserialize)]
pub struct OpenDataResponse<T> {
    /// The parameters relative to the response
    pub parameters: Parameters,

    /// The parameters relative to the pagination
    #[serde(flatten)]
    pub pagination: Pagination,

    /// The sets of records inside the response
    #[serde(bound(deserialize = "T: Deserialize<'de>"))]
    #[serde(deserialize_with = "deserialize::failable_records")]
    pub records: Vec<Record<T>>,
}

/// A record represents an item of some data
/// with a specific id.
#[derive(Debug, Deserialize)]
pub struct Record<T> {
    /// The identifier of the record
    #[serde(rename(deserialize = "recordid"))]
    pub id: String,

    #[serde(rename(deserialize = "fields"))]
    pub(crate) inner: T,
}

#[derive(Debug, Deserialize)]
pub struct StatusOpenData {
    #[serde(rename(deserialize = "idsurfs"))]
    pub id: String,

    #[serde(rename(deserialize = "nom_parking"))]
    pub name: String,

    #[serde(rename(deserialize = "etat"))]
    pub status: i8,

    #[serde(rename(deserialize = "libre"))]
    pub free: u16,

    pub total: u16,

    #[serde(rename(deserialize = "etat_descriptif"))]
    pub users_info: Option<String>,
}

此操作失败，出现了一些错误，如：

应将错误考虑在内：错误（“预期的
，
或
]
”，

我不理解返回错误的原因：
let elements:Vec=Deserialize:：Deserialize（反序列化器）；
尝试对一系列
FailableDeserialize
元素进行反序列化，但这种类型以一种他不能返回错误的方式实现了
反序列化

我错在哪里？
用
ok（）
忽略错误的简单方法将导致反序列化程序的去同步。
反序列化错误可以发生在任何令牌上，并且不需要仅在使用完整元素后发生。
如果反序列化
记录
失败，serde将卡在
记录
对象内，但
Vec
反序列化器需要一个它找不到的
，

如果您坚持使用现有的板条箱，而这些板条箱已经提供了类似于您的
FailableDeserialize
的功能，那么就更容易了。
您可以使用以下方式写入故障记录：

fn可故障的\u记录，
T:反序列化“）]
结构包装器（#[serde_as（反序列化_as=“Vec”）]Vec）；
//从下面的行返回错误
let元素：包装器=反序列化：：反序列化（反序列化器）？；
让result=elements.0.into_iter（）.filter_map（| f | f）.collect（）；
好（结果）
}

在内部，它使用一个未标记的枚举来解决去同步问题，因为这将在开始真正的反序列化之前消耗一个完整的对象。
您是否可以列出一个失败的示例？
struct FailableDeserialize<T> {
    inner: Option<T>,
}

impl<'de, T: Deserialize<'de>> Deserialize<'de> for FailableDeserialize<T> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let value: Option<T> = Deserialize::deserialize(deserializer).ok();
        Ok(FailableDeserialize { inner: value })
    }
}

pub(super) fn failable_records<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
where
    D: Deserializer<'de>,
    T: Deserialize<'de>,
{
    // Error returned from the line below
    let elements: Vec<FailableDeserialize<T>> = Deserialize::deserialize(deserializer)?;
    let result = elements.into_iter().filter_map(|f| f.inner).collect();
    Ok(result)
}