How to ignore unknown enum variant while deserializing? - rust

Question

I have several non-exhaustive enums which I need to handle nicely.
When a not yet known variant is detected, I need to simply ignore value and continue processing the others.
I am currently deserializing vectors of data from and I managed to properly obtain vectors of MyStruct for my application.
My application needs to be forward-compatible with new versions of enums and simply ignores unknown variants.
For example, currently:
use serde::{Deserialize};
#[derive(Deserialize, Debug)]
#[non_exhaustive]
pub enum CaseStyle {
Lowercase,
Uppercase,
}
#[derive(Deserialize, Debug)]
#[non_exhaustive]
pub enum Encoding {
Plain,
Base64,
}
#[derive(Deserialize, Debug)]
pub struct MyStruct {
case_style: CaseStyle,
encoding: Encoding,
}
fn main() {
let j = r#"[
{"case_style": "Lowercase","encoding":"Plain"},
{"case_style": "Snakecase","encoding":"Plain"},
{"case_style": "Lowercase","encoding":"Aes"},
{"case_style": "Uppercase","encoding":"Base64"}
]"#;
// Convert the JSON string to vec.
let deserialized: Vec<MyStruct> = serde_json::from_str(&j).unwrap();
// Prints deserialized = [MyStruct { case_style: Lowercase, encoding: Plain }, MyStruct { case_style: Uppercase, encoding: Base64 }]
println!("deserialized = {:?}", deserialized);
}
This example fails because of the 2 unknown variant in json data. How could I just ignore these unknown variants from the deserialization?

Answer 1

You can deserialize a Vec<Option<MyStruct>> by converting all deserialization errors to None and all successes to Some(...). Afterwards, you can remove the Option by flattening them. You could skip the Option but this would require you to write a custom deserializer for Vec.
Based on the serde_with crate:
use serde::Deserialize;
use serde_with::{serde_as, DefaultOnError};
#[derive(Deserialize, Debug)]
#[non_exhaustive]
pub enum CaseStyle {
Lowercase,
Uppercase,
}
#[derive(Deserialize, Debug)]
#[non_exhaustive]
pub enum Encoding {
Plain,
Base64,
}
#[derive(Deserialize, Debug)]
pub struct MyStruct {
case_style: CaseStyle,
encoding: Encoding,
}
fn main() {
let j = r#"[
{"case_style": "Lowercase","encoding":"Plain"},
{"case_style": "Snakecase","encoding":"Plain"},
{"case_style": "Lowercase","encoding":"Aes"},
{"case_style": "Uppercase","encoding":"Base64"}
]"#;
#[serde_as]
#[derive(Deserialize)]
struct W(#[serde_as(as = "Vec<DefaultOnError>")] Vec<Option<MyStruct>>);
// Convert the JSON string to vec.
let deserialized: Vec<MyStruct> = serde_json::from_str::<W>(&j)
.unwrap()
.0
.into_iter()
.flatten()
.collect();
// Prints deserialized = [MyStruct { case_style: Lowercase, encoding: Plain }, MyStruct { case_style: Uppercase, encoding: Base64 }]
println!("deserialized = {:?}", deserialized);
}

Answer 2

use serde::{Deserialize, Deserializer};
use serde_with::{serde_as, DefaultOnError};
#[derive(Deserialize, Debug)]
#[non_exhaustive]
pub enum CaseStyle {
Lowercase,
Uppercase,
}
#[derive(Deserialize, Debug)]
#[non_exhaustive]
pub enum Encoding {
Plain,
Base64,
}
#[derive(Deserialize, Debug)]
pub struct MyStruct {
case_style: CaseStyle,
encoding: Encoding,
}
#[derive(Deserialize, Debug)]
pub struct VecMyStruct {
#[serde(deserialize_with = "skip_on_error")]
items: Vec<MyStruct>,
}
fn skip_on_error<'de, D>(deserializer: D) -> Result<Vec<MyStruct>, D::Error>
where
D: Deserializer<'de>,
{
#[serde_as]
#[derive(Deserialize, Debug)]
struct MayBeT(#[serde_as(as = "DefaultOnError")] Option<MyStruct>);
let values: Vec<MayBeT> = Deserialize::deserialize(deserializer)?;
Ok(values.into_iter().filter_map(|t| t.0).collect())
}
fn main() {
let j = r#"{"items":[
{"case_style": "Lowercase","encoding":"Plain"},
{"case_style": "Snakecase","encoding":"Plain"},
{"case_style": "Lowercase","encoding":"Aes"},
{"case_style": "Uppercase","encoding":"Base64"}
]}"#;
// Convert the JSON string to vec.
let deserialized: VecMyStruct = serde_json::from_str(&j).unwrap();
// Prints deserialized = VecMyStruct { items: [MyStruct { case_style: Lowercase, encoding: Plain }, MyStruct { case_style: Uppercase, encoding: Base64 }] }
println!("deserialized = {:?}", deserialized);
}
I found this way of doing thanks to #jonasbb. The only issue that I now have is to have a more generic "skip_on_error" method, that could take any T: Deserialize<'de> and not only MyStruct. As soon as I add T type, compiler tells me errors while implementing Deserialization for MaybeT.