Parsing JSON with multiple representation in same attribute

[tangc-JNPR]

I'm relatively new to Rust, and even more so to serde, so I'm having trouble finding out if this is even doable.
I have a JSON file which has two different representations in this form:

"coordinates": [ [ [ 121.423364, 24.9913596 ], [ 121.4233327, 24.9912977 ], ] ]

and this:
"coordinates": [ [ 121.4472492, 25.0052053 ], [ 121.4466457, 25.0028547 ] ]

It shows that it has two dimensions array and three dimensions arrays representing ways in the same attribute.
This makes the file is hard to serialize.

Below is the code that I implement

#[derive(Serialize, Deserialize, Debug)]
struct Geometry {
    #[serde(deserialize_with = "string_or_number", rename = "type")]
    geometry_type: Value,
    #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "coordinates")]
    geometry_coor: Vec<Coordinates>,
    #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "coordinates")]
    geometry_coor2: Vec<Vec<Coordinates>>
}

#[derive(Serialize, Deserialize, Debug)]
struct Coordinates {
    #[serde(deserialize_with = "string_or_number")]
    longitude: Value, 
    #[serde(deserialize_with = "string_or_number")]
    latitude: Value,
}

fn string_or_number<'de, D>(de: D) -> Result<Value, D::Error>
    where D: serde::Deserializer<'de>
{
    let helper: Value = Deserialize::deserialize(de)?;

    match helper {
        Value::Number(n) => {
            println!("{:#?}", n.as_f64().unwrap().to_string());
            Ok(Value::Number(n))
        },
        Value::String(s) => Ok(json!(s)),
        _ => Ok(json!(null))
    }
} 

And I have trouble in struct Geometry which serialize the file of coordinates.
So does there have any ways that I can deal with this kind of form?

[dtolnay]

I would recommend using an untagged enum to represent a coordinate array that can be 2d or 3d.
Playground link

[tangc-JNPR]

Thanks for the help.
I have solved the problem.

Here is the code after modified.

#[derive(Serialize, Deserialize, Debug)]
struct Geometry {
    #[serde(deserialize_with = "string_or_number", rename = "type")]
    geometry_type: Value,
    #[serde(default, skip_serializing_if = "Vec::is_empty", rename = "coordinates")]
    geometry_coor: Vec<Coordinates_form>,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(untagged)]
enum Coordinates_form {
    #[serde(skip_serializing)]
    OneD(Coordinates),
    #[serde(skip_serializing)]
    TwoD(Vec<Coordinates>),
    #[serde(skip_serializing)]
    ThreeD(Vec<Vec<Coordinates>>),
}

#[derive(Deserialize, Debug)]
struct Coordinates {
    #[serde(deserialize_with = "string_or_number")]
    longitude: Value, 
    #[serde(deserialize_with = "string_or_number")]
    latitude: Value,
}

fn string_or_number<'de, D>(de: D) -> Result<Value, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let helper: Value = Deserialize::deserialize(de)?;

    match helper {
        Value::Number(n) => {
            println!("{:#?}", n.as_f64().unwrap().to_string());
            Ok(Value::Number(n))
        }
        Value::String(s) => Ok(json!(s)),
        _ => Ok(json!(null)),
    }
}

[dtolnay]

Nice!