fn output_struct_or_variant_new_type_container()

in serde-generate/src/golang.rs [700:787]

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

    fn output_struct_or_variant_new_type_container(
        &mut self,
        variant_base: Option<&str>,
        variant_index: Option<u32>,
        name: &str,
        format: &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 {} {}", full_name, self.quote_type(format))?;

        // 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)?;
            }
            writeln!(
                self.out,
                "{}",
                self.quote_serialize_value(
                    &format!("(({})(*obj))", self.quote_type(format)),
                    format
                )
            )?;
            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 {}", self.quote_type(format))?;
            writeln!(self.out, "if err := deserializer.IncreaseContainerDepth(); err != nil {{ return ({})(obj), err }}", full_name)?;
            writeln!(
                self.out,
                "{}",
                self.quote_deserialize(format, "obj", &format!("(({})(obj))", full_name))
            )?;
            writeln!(self.out, "deserializer.DecreaseContainerDepth()")?;
            writeln!(self.out, "return ({})(obj), nil", full_name)?;
            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(())
    }