fn output_deserialization_helper()

in serde-generate/src/golang.rs [429:544]

• 110 lines of code
• 10 McCabe index (conditional complexity)

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

        write!(
            self.out,
            "func deserialize_{}(deserializer serde.Deserializer) ({}, error) {{",
            name,
            self.quote_type(format0),
        )?;
        self.out.indent();
        match format0 {
            Option(format) => {
                write!(
                    self.out,
                    r#"
tag, err := deserializer.DeserializeOptionTag()
if err != nil {{ return nil, err }}
if tag {{
	value := new({})
	{}
        return value, nil
}} else {{
	return nil, nil
}}
"#,
                    self.quote_type(format),
                    self.quote_deserialize(format, "*value", "nil"),
                )?;
            }

            Seq(format) => {
                write!(
                    self.out,
                    r#"
length, err := deserializer.DeserializeLen()
if err != nil {{ return nil, err }}
obj := make([]{}, length)
for i := range(obj) {{
	{}
}}
return obj, nil
"#,
                    self.quote_type(format),
                    self.quote_deserialize(format, "obj[i]", "nil")
                )?;
            }

            Map { key, value } => {
                write!(
                    self.out,
                    r#"
length, err := deserializer.DeserializeLen()
if err != nil {{ return nil, err }}
obj := make(map[{0}]{1})
previous_slice := serde.Slice {{ 0, 0 }}
for i := 0; i < int(length); i++ {{
	var slice serde.Slice
	slice.Start = deserializer.GetBufferOffset()
	var key {0}
	{2}
	slice.End = deserializer.GetBufferOffset()
	if i > 0 {{
		err := deserializer.CheckThatKeySlicesAreIncreasing(previous_slice, slice)
		if err != nil {{ return nil, err }}
	}}
	previous_slice = slice
	{3}
}}
return obj, nil
"#,
                    self.quote_type(key),
                    self.quote_type(value),
                    self.quote_deserialize(key, "key", "nil"),
                    self.quote_deserialize(value, "obj[key]", "nil"),
                )?;
            }

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

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

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