fn output_struct_or_variant_container()

in serde-generate/src/golang.rs [598:696]

• 90 lines of code
• 12 McCabe index (conditional complexity)

    fn output_struct_or_variant_container(
        &mut self,
        variant_base: Option<&str>,
        variant_index: Option<u32>,
        name: &str,
        fields: &[Named<Format>],
    ) -> Result<()> {
        let full_name = match variant_base {
            None => name.to_string(),
            Some(base) => format!("{}__{}", base, name),
        };
        // Struct
        writeln!(self.out)?;
        self.output_comment(name)?;
        writeln!(self.out, "type {} struct {{", full_name)?;
        self.enter_class(name);
        for field in fields {
            self.output_comment(&field.name)?;
            writeln!(self.out, "{} {}", field.name, self.quote_type(&field.value))?;
        }
        self.leave_class();
        writeln!(self.out, "}}")?;

        // Link to base interface.
        if let Some(base) = variant_base {
            writeln!(self.out, "\nfunc (*{}) is{}() {{}}", full_name, base)?;
        }

        // Serialize
        if self.generator.config.serialization {
            writeln!(
                self.out,
                "\nfunc (obj *{}) Serialize(serializer serde.Serializer) error {{",
                full_name
            )?;
            self.out.indent();
            writeln!(
                self.out,
                "if err := serializer.IncreaseContainerDepth(); err != nil {{ return err }}"
            )?;
            if let Some(index) = variant_index {
                writeln!(self.out, "serializer.SerializeVariantIndex({})", index)?;
            }
            for field in fields {
                writeln!(
                    self.out,
                    "{}",
                    self.quote_serialize_value(&format!("obj.{}", &field.name), &field.value)
                )?;
            }
            writeln!(self.out, "serializer.DecreaseContainerDepth()")?;
            writeln!(self.out, "return nil")?;
            self.out.unindent();
            writeln!(self.out, "}}")?;

            for encoding in &self.generator.config.encodings {
                self.output_struct_serialize_for_encoding(&full_name, *encoding)?;
            }
        }
        // Deserialize (struct) or Load (variant)
        if self.generator.config.serialization {
            writeln!(
                self.out,
                "\nfunc {0}{1}(deserializer serde.Deserializer) ({1}, error) {{",
                if variant_base.is_none() {
                    "Deserialize"
                } else {
                    "load_"
                },
                full_name,
            )?;
            self.out.indent();
            writeln!(self.out, "var obj {}", full_name)?;
            writeln!(
                self.out,
                "if err := deserializer.IncreaseContainerDepth(); err != nil {{ return obj, err }}"
            )?;
            for field in fields {
                writeln!(
                    self.out,
                    "{}",
                    self.quote_deserialize(&field.value, &format!("obj.{}", field.name), "obj")
                )?;
            }
            writeln!(self.out, "deserializer.DecreaseContainerDepth()")?;
            writeln!(self.out, "return obj, nil")?;
            self.out.unindent();
            writeln!(self.out, "}}")?;

            if variant_base.is_none() {
                for encoding in &self.generator.config.encodings {
                    self.output_struct_deserialize_for_encoding(&full_name, *encoding)?;
                }
            }
        }
        // Custom code
        self.output_custom_code(name)?;
        Ok(())
    }