xml

func Escape ¶

func Escape(w io.Writer, s []byte)

Escape writes to w the properly escaped XML equivalent of the plain text data s.

func Unmarshal ¶

func Unmarshal(r io.Reader, val interface{}) os.Error

Unmarshal parses an XML element from r and uses the reflect library to fill in an arbitrary struct, slice, or string pointed at by val. Well-formed data that does not fit into val is discarded.

For example, given these definitions:

type Email struct {
	Where string "attr"
	Addr  string
}

type Result struct {
	XMLName xml.Name "result"
	Name	string
	Phone	string
	Email	[]Email
	Groups  []string "group>value"
}

result := Result{Name: "name", Phone: "phone", Email: nil}

unmarshalling the XML input

<result>
	<email where="home">
		<addr>[email protected]</addr>
	</email>
	<email where='work'>
		<addr>[email protected]</addr>
	</email>
	<name>Grace R. Emlin</name>
	<group>
		<value>Friends</value>
		<value>Squash</value>
	</group>
	<address>123 Main Street</address>
</result>

via Unmarshal(r, &result) is equivalent to assigning

r = Result{xml.Name{"", "result"},
	"Grace R. Emlin", // name
	"phone",	  // no phone given
	[]Email{
		Email{"home", "[email protected]"},
		Email{"work", "[email protected]"},
	},
	[]string{"Friends", "Squash"},
}

Note that the field r.Phone has not been modified and that the XML <address> element was discarded. Also, the field Groups was assigned considering the element path provided in the field tag.

Because Unmarshal uses the reflect package, it can only assign to upper case fields. Unmarshal uses a case-insensitive comparison to match XML element names to struct field names.

Unmarshal maps an XML element to a struct using the following rules:

• If the struct has a field of type []byte or string with tag "innerxml", Unmarshal accumulates the raw XML nested inside the element in that field. The rest of the rules still apply.

• If the struct has a field named XMLName of type xml.Name, Unmarshal records the element name in that field.

• If the XMLName field has an associated tag string of the form "tag" or "namespace-URL tag", the XML element must have the given tag (and, optionally, name space) or else Unmarshal returns an error.

• If the XML element has an attribute whose name matches a struct field of type string with tag "attr", Unmarshal records the attribute value in that field.

• If the XML element contains character data, that data is accumulated in the first struct field that has tag "chardata". The struct field may have type []byte or string. If there is no such field, the character data is discarded.

• If the XML element contains a sub-element whose name matches the prefix of a struct field tag formatted as "a>b>c", unmarshal will descend into the XML structure looking for elements with the given names, and will map the innermost elements to that struct field. A struct field tag starting with ">" is equivalent to one starting with the field name followed by ">".

• If the XML element contains a sub-element whose name matches a struct field whose tag is neither "attr" nor "chardata", Unmarshal maps the sub-element to that struct field. Otherwise, if the struct has a field named Any, unmarshal maps the sub-element to that struct field.

Unmarshal maps an XML element to a string or []byte by saving the concatenation of that element's character data in the string or []byte.

Unmarshal maps an XML element to a slice by extending the length of the slice and mapping the element to the newly created value.

Unmarshal maps an XML element to a bool by setting it to the boolean value represented by the string.

Unmarshal maps an XML element to an integer or floating-point field by setting the field to the result of interpreting the string value in decimal. There is no check for overflow.

Unmarshal maps an XML element to an xml.Name by recording the element name.

Unmarshal maps an XML element to a pointer by setting the pointer to a freshly allocated value and then mapping the element to that value.