xml

func Marshal ¶

func Marshal(v interface{}) ([]byte, error)

Marshal returns the XML encoding of v.

Marshal handles an array or slice by marshalling each of the elements. Marshal handles a pointer by marshalling the value it points at or, if the pointer is nil, by writing nothing. Marshal handles an interface value by marshalling the value it contains or, if the interface value is nil, by writing nothing. Marshal handles all other data by writing one or more XML elements containing the data.

The name for the XML elements is taken from, in order of preference:

• the tag on the XMLName field, if the data is a struct
• the value of the XMLName field of type xml.Name
• the tag of the struct field used to obtain the data
• the name of the struct field used to obtain the data
• the name of the marshalled type

The XML element for a struct contains marshalled elements for each of the exported fields of the struct, with these exceptions:

• the XMLName field, described above, is omitted.
• a field with tag "-" is omitted.
• a field with tag "name,attr" becomes an attribute with the given name in the XML element.
• a field with tag ",attr" becomes an attribute with the field name in the XML element.
• a field with tag ",chardata" is written as character data, not as an XML element.
• a field with tag ",innerxml" is written verbatim, not subject to the usual marshalling procedure.
• a field with tag ",comment" is written as an XML comment, not subject to the usual marshalling procedure. It must not contain the "--" string within it.
• a field with a tag including the "omitempty" option is omitted if the field value is empty. The empty values are false, 0, any nil pointer or interface value, and any array, slice, map, or string of length zero.
• an anonymous struct field is handled as if the fields of its value were part of the outer struct.

If a field uses a tag "a>b>c", then the element c will be nested inside parent elements a and b. Fields that appear next to each other that name the same parent will be enclosed in one XML element.

See MarshalIndent for an example.

Marshal will return an error if asked to marshal a channel, function, or map.

func MarshalIndent ¶

func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)

MarshalIndent works like Marshal, but each XML element begins on a new indented line that starts with prefix and is followed by one or more copies of indent according to the nesting depth.

package main

import (
	"encoding/xml"
	"fmt"
	"os"
)

func main() {
	type Address struct {
		City, State string
	}
	type Person struct {
		XMLName   xml.Name `xml:"person"`
		Id        int      `xml:"id,attr"`
		FirstName string   `xml:"name>first"`
		LastName  string   `xml:"name>last"`
		Age       int      `xml:"age"`
		Height    float32  `xml:"height,omitempty"`
		Married   bool
		Address
		Comment string `xml:",comment"`
	}

	v := &Person{Id: 13, FirstName: "John", LastName: "Doe", Age: 42}
	v.Comment = " Need more details. "
	v.Address = Address{"Hanga Roa", "Easter Island"}

	output, err := xml.MarshalIndent(v, "  ", "    ")
	if err != nil {
		fmt.Printf("error: %v\n", err)
	}

	os.Stdout.Write(output)
}

Output:

  <person id="13">
      <name>
          <first>John</first>
          <last>Doe</last>
      </name>
      <age>42</age>
      <Married>false</Married>
      <City>Hanga Roa</City>
      <State>Easter Island</State>
      <!-- Need more details. -->
  </person>

func SetUseNullEndTag ¶

func SetUseNullEndTag(b bool)

SetUseNullEndTag - 'true': have Marshal/MarshalIndent use <tag .../> in place of <tag ...></tag> for empty element.

package main

import (
	"encoding/xml"
	"fmt"
)

func main() {
	type NullValStruct struct {
		I int
		B []byte
		S string
	}
	s := new(NullValStruct)

	v, err := xml.Marshal(s)
	if err != nil {
		fmt.Println("err:", err.Error())
	} else {
		fmt.Println("s:", string(v))
	}

	xml.SetUseNullEndTag(true)
	v, err = xml.Marshal(s)
	if err != nil {
		fmt.Println("err:", err.Error())
	} else {
		fmt.Println("s:", string(v))
	}

	type NewStruct struct {
		NVS NullValStruct
		S   string
		F   float64
	}
	ss := new(NewStruct)

	v, err = xml.Marshal(ss)
	if err != nil {
		fmt.Println("err:", err.Error())
	} else {
		fmt.Println("ss:", string(v))
	}

	v, err = xml.MarshalIndent(ss, "  ", "   ")
	if err != nil {
		fmt.Println("err:", err.Error())
	} else {
		fmt.Println("ss indent:\n", string(v))
	}
}

Output:

s: <NullValStruct><I>0</I><B></B><S></S></NullValStruct>
s: <NullValStruct><I>0</I><B/><S/></NullValStruct>
ss: <NewStruct><NVS><I>0</I><B/><S/></NVS><S/><F>0</F></NewStruct>
ss indent:
   <NewStruct>
     <NVS>
        <I>0</I>
        <B/>
        <S/>
     </NVS>
     <S/>
     <F>0</F>
  </NewStruct>