How can I parse a JSON array of either strings or objects?

Question

An API I hit has poorly structured JSON. Someone decided that it was a great idea to send back a list that looks like this

features: [ "First one", "second one", { "feature": "third one", "hasAdditionalImpact": true }, "forth one" ]

I've figured out a way to get this data into a struct but that was effectively:

struct MyStruct { SensibleData: String, SensibleTruthy: bool, features: serde_json::Value, }

This doesn't help me normalize and verify the data.

Is there a good way to turn that first object into something like

features: [ { "feature": "First one", "hasAdditionalImpact": false }, { "feature": "second one", "hasAdditonalImpact": false }, { "feature": "third one", "hasAdditionalImpact": true }, { "feature": "forth one", "hasAdditionalImpact": false } ]

I saw type_name might be usable for checking the type and doing post-processing after it's be parsed by serde_json, but I also saw that type_name is for diagnostic purposes so I'd rather not use that for this purpose.

It looks like your question might be answered by the answers of How to conditionally deserialize JSON to two different variants of an enum?; Convert two types into a single type with Serde; How to deserialize JSON where the types of the values are specified in another field?. If not, please edit your question to explain the differences. Otherwise, we can mark this question as already answered. — Shepmaster
– Shepmaster, Commented Jul 2, 2021 at 20:59
See also Rust serde deserializing a mixed array; Deserializing JSON array containing different types of object. Really, there's quite a lot of results from casual searching. — Shepmaster
– Shepmaster, Commented Jul 2, 2021 at 21:01

Peter Hall · Accepted Answer · 2021-07-02 21:08:07Z

It looks like the features in your JSON have two forms; an explicit object and a simplified form where some fields are defaulted or unnamed. You can model that with an eum like this:

#[derive(Deserialize, Debug)] #[serde(untagged)] enum Feature { Simple(String), Explicit { feature: String, #[serde(rename = "hasAdditionalImpact")] has_additional_impact: bool, } }

(playground)

The #[serde(untagged)] attribute means it will attempt to deserialize into each variant in order until one succeeds.

If the enum is going to be annoying, you can convert them all into the same struct, with default values, using #[serde(from)] and providing a From conversion:

#[derive(Deserialize, Debug)] #[serde(untagged)] enum FeatureSource { Simple(String), Explicit { feature: String, #[serde(rename = "hasAdditionalImpact")] has_additional_impact: bool, }, } #[derive(Deserialize, Debug)] #[serde(from = "FeatureSource")] struct Feature { feature: String, has_additional_impact: bool, } impl From<FeatureSource> for Feature { fn from(other: FeatureSource) -> Feature { match other { FeatureSource::Simple(feature) => Feature { feature, has_additional_impact: false, }, FeatureSource::Explicit { feature, has_additional_impact, } => Feature { feature, has_additional_impact, }, } } }

(playground)

FeatureSource is only used as an intermediate representation and converted to Feature before the rest of your code ever sees it.

Sorry it took me a bit to reply; thank you so much! This is awesome. The second one is perfect and I can use that to extrapolate what I need to do for the rest of this strange parsing for this project as well! I've accepted and upvoted your answer. You're great!

Collectives™ on Stack Overflow

How can I parse a JSON array of either strings or objects?

1 Answer 1

1 Comment

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Linked

Related