xml: unsupported type: map[string]int

// StringMap is a map[string]string.
type StringMap map[string]string
// StringMap marshals into XML.
func (s StringMap) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	tokens := []xml.Token{start}
	for key, value := range s {
		t := xml.StartElement{Name: xml.Name{"", key}}
		tokens = append(tokens, t, xml.CharData(value), xml.EndElement{t.Name})
	}
	tokens = append(tokens, xml.EndElement{start.Name})
	for _, t := range tokens {
		err := e.EncodeToken(t)
		if err != nil {
			return err
		}
	}
  	// flush to ensure tokens are written
	return e.Flush()
}

output, err := xml.MarshalIndent(data, "", "  ")

package main
import (
"encoding/xml"
"fmt"
"io"
)
type Map map[string]string
type xmlMapEntry struct {
XMLName xml.Name
Value   string `xml:",chardata"`
}
// MarshalXML marshals the map to XML, with each key in the map being a
// tag and it's corresponding value being it's contents.
func (m Map) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
if len(m) == 0 {
return nil
}
err := e.EncodeToken(start)
if err != nil {
return err
}
for k, v := range m {
e.Encode(xmlMapEntry{XMLName: xml.Name{Local: k}, Value: v})
}
return e.EncodeToken(start.End())
}
// UnmarshalXML unmarshals the XML into a map of string to strings,
// creating a key in the map for each tag and setting it's value to the
// tags contents.
//
// The fact this function is on the pointer of Map is important, so that
// if m is nil it can be initialized, which is often the case if m is
// nested in another xml structurel. This is also why the first thing done
// on the first line is initialize it.
func (m *Map) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
*m = Map{}
for {
var e xmlMapEntry
err := d.Decode(&e)
if err == io.EOF {
break
} else if err != nil {
return err
}
(*m)[e.XMLName.Local] = e.Value
}
return nil
}
func main() {
// The Map
m := map[string]string{
"key_1": "Value One",
"key_2": "Value Two",
}
fmt.Println(m)
// Encode to XML
x, _ := xml.MarshalIndent(Map(m), "", "  ")
fmt.Println(string(x))
// Decode back from XML
var rm map[string]string
xml.Unmarshal(x, (*Map)(&rm))
fmt.Println(rm)
}

Marshal handles an array or slice by marshalling each of the elements.