func StructToXML()

in testing/xml/xmlToStruct.go [135:193]
49 lines of code
14 McCabe index (conditional complexity)

func StructToXML(e *xml.Encoder, node *XMLNode, sorted bool) error {
	var err error
	// Sort Attributes
	attrs := node.Attr
	if sorted {
		sortedAttrs := make([]xml.Attr, len(attrs))
		for _, k := range node.Attr {
			sortedAttrs = append(sortedAttrs, k)
		}
		sort.Sort(xmlAttrSlice(sortedAttrs))
		attrs = sortedAttrs
	}

	st := xml.StartElement{Name: node.Name, Attr: attrs}
	e.EncodeToken(st)
	// return fmt.Errorf("encoder string : %s, %s, %s", node.Name.Local, node.Name.Space, st.Attr)

	if node.Text != "" {
		e.EncodeToken(xml.CharData([]byte(node.Text)))
	} else if sorted {
		sortedNames := []string{}
		for k := range node.Children {
			sortedNames = append(sortedNames, k)
		}
		sort.Strings(sortedNames)

		for _, k := range sortedNames {
			// we should sort the []*xml.Node for each key if len >1
			flattenedNodes := node.Children[k]
			// Meaning this has multiple nodes
			if len(flattenedNodes) > 1 {
				// sort flattened nodes
				flattenedNodes, err = sortFlattenedNodes(flattenedNodes)
				if err != nil {
					return err
				}
			}

			for _, v := range flattenedNodes {
				err = StructToXML(e, v, sorted)
				if err != nil {
					return err
				}
			}
		}
	} else {
		for _, c := range node.Children {
			for _, v := range c {
				err = StructToXML(e, v, sorted)
				if err != nil {
					return err
				}
			}
		}
	}

	e.EncodeToken(xml.EndElement{Name: node.Name})
	return e.Flush()
}