extern crate serde; // 1.0.80
extern crate serde_json; // 1.0.32
#[macro_use]
extern crate serde_derive; // 1.0.80

use serde::de;
use std::fmt;

#[derive(Debug, Default, PartialEq)]
struct Outer {
    name: String,
    count: i64,
    key_string: String,
    key_object: Inner,
}

#[derive(Debug, Default, PartialEq, Deserialize)]
struct Inner {
    value: Option<String>,
}

struct OuterVisitor;

impl<'de> de::Visitor<'de> for OuterVisitor {
    type Value = Outer;

    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "an Outer struct")
    }

    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
    where
        A: de::MapAccess<'de>
    {
        let (mut name, mut count, mut key_string, mut key_object) = (None, None, None, None);

        while let Some(key) = map.next_key::<String>()? {
            match key.as_ref() {
                "name" => name = Some(map.next_value::<String>()?),
                "count" => count = Some(map.next_value::<i64>()?),
                _ => {
                    key_string = Some(key);
                    key_object = Some(map.next_value::<Inner>()?);
                }
            }
        }

        if name.is_none() {
            Err(de::Error::custom("missing field: 'name'"))
        } else if count.is_none() {
            Err(de::Error::custom("missing field: 'count'"))
        } else if key_string.is_none() || key_object.is_none() {
            Err(de::Error::custom("missing key or key object"))
        } else {
            Ok(Outer {
                name: name.unwrap(),
                count: count.unwrap(),
                key_string: key_string.unwrap(),
                key_object: key_object.unwrap(),
            })
        }
    }
}

impl<'de> de::Deserialize<'de> for Outer {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: de::Deserializer<'de>,
    {
        deserializer.deserialize_map(OuterVisitor)
    }
}

fn main() {
    let json = r#"
    {
        "name": "abc",
        "count": 123,
        "some-random-key": {
            "value": "foobar"
        }
    }
    "#;

    let expected = Outer {
        name: "abc".to_string(),
        count: 123,
        key_string: "some-random-key".to_string(),
        key_object: Inner {
            value: Some("foobar".to_string()),
        },
    };

    assert_eq!(serde_json::from_str::<Outer>(json).unwrap(), expected);
}