fn output_serialization_helper()

in serde-generate/src/golang.rs [343:427]

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

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

        write!(
            self.out,
            "func serialize_{}(value {}, serializer serde.Serializer) error {{",
            name,
            self.quote_type(format0)
        )?;
        self.out.indent();
        match format0 {
            Option(format) => {
                write!(
                    self.out,
                    r#"
if value != nil {{
	if err := serializer.SerializeOptionTag(true); err != nil {{ return err }}
	{}
}} else {{
	if err := serializer.SerializeOptionTag(false); err != nil {{ return err }}
}}
"#,
                    self.quote_serialize_value("(*value)", format)
                )?;
            }

            Seq(format) => {
                write!(
                    self.out,
                    r#"
if err := serializer.SerializeLen(uint64(len(value))); err != nil {{ return err }}
for _, item := range(value) {{
	{}
}}
"#,
                    self.quote_serialize_value("item", format)
                )?;
            }

            Map { key, value } => {
                write!(
                    self.out,
                    r#"
if err := serializer.SerializeLen(uint64(len(value))); err != nil {{ return err }}
offsets := make([]uint64, len(value))
count := 0
for k, v := range(value) {{
	offsets[count] = serializer.GetBufferOffset()
	count += 1
	{}
	{}
}}
serializer.SortMapEntries(offsets);
"#,
                    self.quote_serialize_value("k", key),
                    self.quote_serialize_value("v", value)
                )?;
            }

            Tuple(formats) => {
                writeln!(self.out)?;
                for (index, format) in formats.iter().enumerate() {
                    let expr = format!("value.Field{}", index);
                    writeln!(self.out, "{}", self.quote_serialize_value(&expr, format))?;
                }
            }

            TupleArray { content, size: _ } => {
                write!(
                    self.out,
                    r#"
for _, item := range(value) {{
	{}
}}
"#,
                    self.quote_serialize_value("item", content),
                )?;
            }

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