go-pkg-xmlx/node.go

381 lines
8.7 KiB
Go
Raw Normal View History

// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
// license. Its contents can be found at:
// http://creativecommons.org/publicdomain/zero/1.0/
package xmlx
import (
"bytes"
2011-11-09 13:56:55 +00:00
"encoding/xml"
"fmt"
"strconv"
)
const (
NT_ROOT = iota
NT_DIRECTIVE
NT_PROCINST
NT_COMMENT
NT_ELEMENT
)
type Attr struct {
Name xml.Name // Attribute namespace and name.
Value string // Attribute value.
}
type Node struct {
Type byte // Node type.
Name xml.Name // Node namespace and name.
Children []*Node // Child nodes.
Attributes []*Attr // Node attributes.
Parent *Node // Parent node.
Value string // Node value.
Target string // procinst field.
}
func NewNode(tid byte) *Node {
n := new(Node)
n.Type = tid
n.Children = make([]*Node, 0, 10)
n.Attributes = make([]*Attr, 0, 10)
return n
}
2010-05-06 03:36:48 +00:00
// This wraps the standard xml.Unmarshal function and supplies this particular
2009-12-02 18:38:35 +00:00
// node as the content to be unmarshalled.
2011-11-02 15:50:45 +00:00
func (this *Node) Unmarshal(obj interface{}) error {
2012-01-27 10:51:02 +00:00
return xml.NewDecoder(bytes.NewBuffer(this.Bytes())).Decode(obj)
2009-12-02 18:38:35 +00:00
}
2009-11-23 05:40:57 +00:00
// Get node value as string
func (this *Node) S(namespace, name string) string {
if node := rec_SelectNode(this, namespace, name); node != nil {
return node.Value
2010-05-06 03:36:48 +00:00
}
return ""
2009-11-23 05:40:57 +00:00
}
// Get node value as int
func (this *Node) I(namespace, name string) int {
if node := rec_SelectNode(this, namespace, name); node != nil && node.Value != "" {
n, _ := strconv.Atoi(node.Value)
return n
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:40:57 +00:00
}
// Get node value as int64
func (this *Node) I64(namespace, name string) int64 {
if node := rec_SelectNode(this, namespace, name); node != nil && node.Value != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseInt(node.Value, 10, 64)
return n
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:40:57 +00:00
}
// Get node value as uint
func (this *Node) U(namespace, name string) uint {
if node := rec_SelectNode(this, namespace, name); node != nil && node.Value != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseUint(node.Value, 10, 0)
2011-12-07 12:57:00 +00:00
return uint(n)
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:40:57 +00:00
}
// Get node value as uint64
func (this *Node) U64(namespace, name string) uint64 {
if node := rec_SelectNode(this, namespace, name); node != nil && node.Value != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseUint(node.Value, 10, 64)
return n
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:40:57 +00:00
}
// Get node value as float32
func (this *Node) F32(namespace, name string) float32 {
if node := rec_SelectNode(this, namespace, name); node != nil && node.Value != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseFloat(node.Value, 32)
2011-12-07 12:57:00 +00:00
return float32(n)
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:40:57 +00:00
}
// Get node value as float64
func (this *Node) F64(namespace, name string) float64 {
if node := rec_SelectNode(this, namespace, name); node != nil && node.Value != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseFloat(node.Value, 64)
return n
2010-05-06 03:36:48 +00:00
}
return 0
}
// Get node value as bool
func (this *Node) B(namespace, name string) bool {
if node := rec_SelectNode(this, namespace, name); node != nil && node.Value != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseBool(node.Value)
return n
}
return false
2009-11-23 05:40:57 +00:00
}
2009-11-23 05:15:40 +00:00
// Get attribute value as string
func (this *Node) As(namespace, name string) string {
2010-05-06 03:36:48 +00:00
for _, v := range this.Attributes {
if (namespace == "*" || namespace == v.Name.Space) && name == v.Name.Local {
2010-05-06 03:36:48 +00:00
return v.Value
2009-11-23 05:15:40 +00:00
}
}
2010-05-06 03:36:48 +00:00
return ""
2009-11-23 05:15:40 +00:00
}
// Get attribute value as int
func (this *Node) Ai(namespace, name string) int {
if s := this.As(namespace, name); s != "" {
n, _ := strconv.Atoi(s)
return n
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:15:40 +00:00
}
// Get attribute value as uint
func (this *Node) Au(namespace, name string) uint {
if s := this.As(namespace, name); s != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseUint(s, 10, 0)
2011-12-07 12:57:00 +00:00
return uint(n)
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:15:40 +00:00
}
// Get attribute value as uint64
func (this *Node) Au64(namespace, name string) uint64 {
if s := this.As(namespace, name); s != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseUint(s, 10, 64)
return n
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:15:40 +00:00
}
// Get attribute value as int64
func (this *Node) Ai64(namespace, name string) int64 {
if s := this.As(namespace, name); s != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseInt(s, 10, 64)
return n
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:15:40 +00:00
}
// Get attribute value as float32
func (this *Node) Af32(namespace, name string) float32 {
if s := this.As(namespace, name); s != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseFloat(s, 32)
2011-12-07 12:57:00 +00:00
return float32(n)
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:15:40 +00:00
}
// Get attribute value as float64
func (this *Node) Af64(namespace, name string) float64 {
if s := this.As(namespace, name); s != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseFloat(s, 64)
return n
2010-05-06 03:36:48 +00:00
}
return 0
2009-11-23 05:15:40 +00:00
}
// Get attribute value as bool
func (this *Node) Ab(namespace, name string) bool {
if s := this.As(namespace, name); s != "" {
2011-12-07 12:53:17 +00:00
n, _ := strconv.ParseBool(s)
return n
}
return false
}
2009-11-23 05:15:40 +00:00
// Returns true if this node has the specified attribute. False otherwise.
func (this *Node) HasAttr(namespace, name string) bool {
2010-05-06 03:36:48 +00:00
for _, v := range this.Attributes {
if namespace != "*" && namespace != v.Name.Space {
continue
}
if name == "*" || name == v.Name.Local {
2009-11-23 05:15:40 +00:00
return true
}
}
2009-11-23 05:15:40 +00:00
return false
}
// Select single node by name
func (this *Node) SelectNode(namespace, name string) *Node {
2010-05-06 03:36:48 +00:00
return rec_SelectNode(this, namespace, name)
}
func rec_SelectNode(cn *Node, namespace, name string) *Node {
if (namespace == "*" || cn.Name.Space == namespace) && (name == "*" || cn.Name.Local == name) {
2010-05-06 03:36:48 +00:00
return cn
}
var tn *Node
for _, v := range cn.Children {
if tn = rec_SelectNode(v, namespace, name); tn != nil {
2010-05-06 03:36:48 +00:00
return tn
}
}
2010-05-06 03:36:48 +00:00
return nil
}
2009-11-23 05:15:40 +00:00
// Select multiple nodes by name
func (this *Node) SelectNodes(namespace, name string) []*Node {
list := make([]*Node, 0, 16)
rec_SelectNodes(this, namespace, name, &list, false)
2010-05-06 03:36:48 +00:00
return list
}
// Select multiple nodes by name
func (this *Node) SelectNodesRecursive(namespace, name string) []*Node {
list := make([]*Node, 0, 16)
rec_SelectNodes(this, namespace, name, &list, true)
return list
}
func rec_SelectNodes(cn *Node, namespace, name string, list *[]*Node, recurse bool) {
if (namespace == "*" || cn.Name.Space == namespace) && (name == "*" || cn.Name.Local == name) {
2010-11-05 00:26:35 +00:00
*list = append(*list, cn)
if !recurse {
return
}
}
for _, v := range cn.Children {
rec_SelectNodes(v, namespace, name, list, recurse)
}
}
// Convert node to appropriate []byte representation based on it's @Type.
2010-05-06 03:36:48 +00:00
// Note that NT_ROOT is a special-case empty node used as the root for a
2009-11-23 05:15:40 +00:00
// Document. This one has no representation by itself. It merely forwards the
// String() call to it's child nodes.
func (this *Node) Bytes() (b []byte) {
switch this.Type {
case NT_PROCINST:
b = this.printProcInst()
case NT_COMMENT:
b = this.printComment()
case NT_DIRECTIVE:
b = this.printDirective()
case NT_ELEMENT:
b = this.printElement()
case NT_ROOT:
b = this.printRoot()
}
2010-05-06 03:36:48 +00:00
return
}
// Convert node to appropriate string representation based on it's @Type.
// Note that NT_ROOT is a special-case empty node used as the root for a
// Document. This one has no representation by itself. It merely forwards the
// String() call to it's child nodes.
func (this *Node) String() (s string) {
return string(this.Bytes())
}
func (this *Node) printRoot() []byte {
var b bytes.Buffer
for _, v := range this.Children {
b.Write(v.Bytes())
}
return b.Bytes()
}
func (this *Node) printProcInst() []byte {
return []byte("<?" + this.Target + " " + this.Value + "?>")
}
func (this *Node) printComment() []byte {
return []byte("<!-- " + this.Value + " -->")
}
func (this *Node) printDirective() []byte {
return []byte("<!" + this.Value + "!>")
}
func (this *Node) printElement() []byte {
var b bytes.Buffer
if len(this.Name.Space) > 0 {
b.WriteRune('<')
b.WriteString(this.Name.Space)
b.WriteRune(':')
b.WriteString(this.Name.Local)
} else {
b.WriteRune('<')
b.WriteString(this.Name.Local)
}
for _, v := range this.Attributes {
if len(v.Name.Space) > 0 {
b.WriteString(fmt.Sprintf(` %s:%s="%s"`, v.Name.Space, v.Name.Local, v.Value))
} else {
b.WriteString(fmt.Sprintf(` %s="%s"`, v.Name.Local, v.Value))
}
}
if len(this.Children) == 0 && len(this.Value) == 0 {
b.WriteString(" />")
return b.Bytes()
}
b.WriteRune('>')
for _, v := range this.Children {
b.Write(v.Bytes())
}
b.WriteString(this.Value)
if len(this.Name.Space) > 0 {
b.WriteString("</")
b.WriteString(this.Name.Space)
b.WriteRune(':')
b.WriteString(this.Name.Local)
b.WriteRune('>')
} else {
b.WriteString("</")
b.WriteString(this.Name.Local)
b.WriteRune('>')
}
return b.Bytes()
}
2009-11-23 05:15:40 +00:00
// Add a child node
func (this *Node) AddChild(t *Node) {
if t.Parent != nil {
t.Parent.RemoveChild(t)
}
2010-05-06 03:36:48 +00:00
t.Parent = this
2010-11-05 00:26:35 +00:00
this.Children = append(this.Children, t)
}
2009-11-23 05:15:40 +00:00
// Remove a child node
func (this *Node) RemoveChild(t *Node) {
2010-05-06 03:36:48 +00:00
p := -1
for i, v := range this.Children {
if v == t {
2010-05-06 03:36:48 +00:00
p = i
break
}
}
2010-05-06 03:36:48 +00:00
if p == -1 {
return
}
copy(this.Children[p:], this.Children[p+1:])
this.Children = this.Children[0 : len(this.Children)-1]
2010-05-06 03:36:48 +00:00
t.Parent = nil
}