fn output_deserialization_helper()

in serde-generate/src/dart.rs [471:576]

• 100 lines of code
• 6 McCabe index (conditional complexity)

    fn output_deserialization_helper(&mut self, name: &str, format0: &Format) -> Result<()> {
        use Format::*;

        write!(
            self.out,
            "static {} deserialize{}(BinaryDeserializer deserializer) {{",
            self.quote_type(format0),
            name.to_camel_case(),
        )?;
        self.out.indent();
        match format0 {
            Option(format) => {
                write!(
                    self.out,
                    r#"
final tag = deserializer.deserializeOptionTag();
if (tag) {{
    return {};
}} else {{
    return null;
}}
"#,
                    self.quote_deserialize(format),
                )?;
            }

            Seq(format) => {
                write!(
                    self.out,
                    r#"
final length = deserializer.deserializeLength();
return List.generate(length, (_i) => {0});
"#,
                    self.quote_deserialize(format)
                )?;
            }

            Map { key, value } => {
                write!(
                    self.out,
                    r#"
final length = deserializer.deserializeLength();
final obj = <{0}, {1}>{{}};
var previousKeyStart = 0;
var previousKeyEnd = 0;
for (var i = 0; i < length; i++) {{
    final keyStart = deserializer.offset;
    {0} key = {2};
    final keyEnd = deserializer.offset;
    if (i > 0) {{
        deserializer.checkThatKeySlicesAreIncreasing(
            Slice(previousKeyStart, previousKeyEnd),
            Slice(keyStart, keyEnd),
        );
    }}
    previousKeyStart = keyStart;
    previousKeyEnd = keyEnd;
    {1} value = {3};
    obj.putIfAbsent(key, () => value);
}}
return obj;
"#,
                    self.quote_type(key),
                    self.quote_type(value),
                    self.quote_deserialize(key),
                    self.quote_deserialize(value),
                )?;
            }

            Tuple(formats) => {
                write!(
                    self.out,
                    r#"
return {}({}
);
"#,
                    self.quote_type(format0),
                    formats
                        .iter()
                        .map(|f| format!("\n    {}", self.quote_deserialize(f)))
                        .collect::<Vec<_>>()
                        .join(",")
                )?;
            }

            TupleArray { content, size } => {
                write!(
                    self.out,
                    r#"
final obj = List<{0}>.filled({1}, 0);
for (var i = 0; i < {1}; i++) {{
    obj[i] = {2};
}}
return obj;
"#,
                    self.quote_type(content),
                    size,
                    self.quote_deserialize(content)
                )?;
            }

            _ => panic!("unexpected case"),
        }
        self.out.unindent();
        writeln!(self.out, "}}\n")
    }