xml

package
Version: v0.0.0-...-37f655d Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 1, 2019 License: MIT Imports: 9 Imported by: 43

Documentation

Index

Constants

View Source
const DefaultEncoding = "utf-8"

DefaultEncoding is UTF-8, which is also the default for both libxml2 and Go strings.

Variables

View Source
var (
	ERR_UNDEFINED_COERCE_PARAM               = errors.New("unexpected parameter type in coerce")
	ERR_UNDEFINED_SET_CONTENT_PARAM          = errors.New("unexpected parameter type in SetContent")
	ERR_UNDEFINED_SEARCH_PARAM               = errors.New("unexpected parameter type in Search")
	ERR_CANNOT_MAKE_DUCMENT_AS_CHILD         = errors.New("cannot add a document node as a child")
	ERR_CANNOT_COPY_TEXT_NODE_WHEN_ADD_CHILD = errors.New("cannot copy a text node when adding it")
)
View Source
var DefaultEncodingBytes = []byte(DefaultEncoding)

DefaultEncodingBytes allows us to conveniently pass the DefaultEncoding to various functions that expect the encoding as a byte array.

View Source
var ERR_FAILED_TO_PARSE_XML = errors.New("failed to parse xml input")
View Source
var ErrEmptyFragment = errors.New("empty xml fragment")
View Source
var ErrFailParseFragment = errors.New("failed to parse xml fragment")
View Source
var ErrTooLarge = errors.New("Output buffer too large")

run out of memory

Functions

This section is empty.

Types

type AttributeNode

type AttributeNode struct {
	*XmlNode
}

AttributeNode represents an attribute, which has a name and a value.

AttributeNodes are created by calling SetAttr or SetNsAttr on an element node, and retrieved by the Attribute and Attributes functions on an element node.

Note that while mamespace declarations resemble attributes, they are a distinct node type and cannot be used or retrieved as an AttributeNode.

func (*AttributeNode) SetValue

func (attrNode *AttributeNode) SetValue(val interface{})

SetValue sets the value of the attribute. Note that the argument will be converted to a string, and automatically XML-escaped when the document is serialized.

func (*AttributeNode) String

func (attrNode *AttributeNode) String() string

String returns the value of the attribute.

func (*AttributeNode) Value

func (attrNode *AttributeNode) Value() string

Value returns the value of the attribute.

type CDataNode

type CDataNode struct {
	*XmlNode
}
CDataNode represents a CDATA section. This XML node type allows the embedding of unescaped, verbatim text within an XML document.

It is otherwise identical to a TextNode. It is most often used to wrap content that is whitespace-sensitive or likely to contain large numbers of less-than or greater-than signs (such as code snippets or example documents).

If you use the XML_PARSE_NOCDATA parsing option, the parser will always present the CDATA sections as TextNodes.

type CommentNode

type CommentNode struct {
	*XmlNode
}

type Document

type Document interface {
	/* Nokogiri APIs */
	CreateElementNode(string) *ElementNode
	CreateCDataNode(string) *CDataNode
	CreateTextNode(string) *TextNode
	CreateCommentNode(string) *CommentNode
	CreatePINode(string, string) *ProcessingInstructionNode
	ParseFragment([]byte, []byte, ParseOption) (*DocumentFragment, error)

	DocPtr() unsafe.Pointer
	DocType() NodeType
	DocRef() Document
	InputEncoding() []byte
	OutputEncoding() []byte
	DocXPathCtx() *xpath.XPath
	AddUnlinkedNode(unsafe.Pointer)
	RemoveUnlinkedNode(unsafe.Pointer) bool
	Free()
	String() string
	Root() *ElementNode
	NodeById(string) *ElementNode
	BookkeepFragment(*DocumentFragment)

	RecursivelyRemoveNamespaces() error
	UnparsedEntityURI(string) string
	Uri() string
}

type DocumentFragment

type DocumentFragment struct {
	Node
	InEncoding  []byte
	OutEncoding []byte
}

func ParseFragment

func ParseFragment(content, inEncoding, url []byte, options ParseOption, outEncoding []byte) (fragment *DocumentFragment, err error)

func (*DocumentFragment) Children

func (fragment *DocumentFragment) Children() []Node

func (*DocumentFragment) Remove

func (fragment *DocumentFragment) Remove()

func (*DocumentFragment) String

func (fragment *DocumentFragment) String() string

func (*DocumentFragment) ToBuffer

func (fragment *DocumentFragment) ToBuffer(outputBuffer []byte) []byte

type ElementNode

type ElementNode struct {
	*XmlNode
}

type NamespaceDeclaration

type NamespaceDeclaration struct {
	Prefix string
	Uri    string
}

NamespaceDeclaration represents a namespace declaration, providing both the prefix and the URI of the namespace. It is returned by the DeclaredNamespaces function.

type Node

type Node interface {
	NodePtr() unsafe.Pointer
	ResetNodePtr()
	MyDocument() Document

	IsValid() bool

	ParseFragment([]byte, []byte, ParseOption) (*DocumentFragment, error)
	LineNumber() int

	//
	NodeType() NodeType
	NextSibling() Node
	PreviousSibling() Node

	Parent() Node
	FirstChild() Node
	LastChild() Node
	CountChildren() int
	Attributes() map[string]*AttributeNode
	AttributeList() []*AttributeNode

	Coerce(interface{}) ([]Node, error)

	AddChild(interface{}) error
	AddPreviousSibling(interface{}) error
	AddNextSibling(interface{}) error
	InsertBefore(interface{}) error
	InsertAfter(interface{}) error
	InsertBegin(interface{}) error
	InsertEnd(interface{}) error
	SetInnerHtml(interface{}) error
	SetChildren(interface{}) error
	Replace(interface{}) error
	Wrap(string) error

	SetContent(interface{}) error

	Name() string
	SetName(string)

	Attr(string) string
	SetAttr(string, string) string
	SetNsAttr(string, string, string) string
	Attribute(string) *AttributeNode

	Path() string

	Duplicate(int) Node
	DuplicateTo(Document, int) Node

	Search(interface{}) ([]Node, error)
	SearchWithVariables(interface{}, xpath.VariableScope) ([]Node, error)
	EvalXPath(interface{}, xpath.VariableScope) (interface{}, error)
	EvalXPathAsBoolean(interface{}, xpath.VariableScope) bool

	Unlink()
	Remove()
	ResetChildren()

	SerializeWithFormat(SerializationOption, []byte, []byte) ([]byte, int)
	ToXml([]byte, []byte) ([]byte, int)
	ToUnformattedXml() string
	ToHtml([]byte, []byte) ([]byte, int)
	ToBuffer([]byte) []byte
	String() string
	Content() string
	InnerHtml() string

	RecursivelyRemoveNamespaces() error
	Namespace() string
	SetNamespace(string, string)
	DeclareNamespace(string, string)
	RemoveDefaultNamespace()
	DeclaredNamespaces() []NamespaceDeclaration
}

func NewNode

func NewNode(nodePtr unsafe.Pointer, document Document) (node Node)

NewNode takes a C pointer from the libxml2 library and returns a Node instance of the appropriate type.

type NodeType

type NodeType int

NodeType is an enumeration that indicates the type of XmlNode.

const (
	XML_ELEMENT_NODE NodeType = iota + 1
	XML_ATTRIBUTE_NODE
	XML_TEXT_NODE
	XML_CDATA_SECTION_NODE
	XML_ENTITY_REF_NODE
	XML_ENTITY_NODE
	XML_PI_NODE
	XML_COMMENT_NODE
	XML_DOCUMENT_NODE
	XML_DOCUMENT_TYPE_NODE
	XML_DOCUMENT_FRAG_NODE
	XML_NOTATION_NODE
	XML_HTML_DOCUMENT_NODE
	XML_DTD_NODE
	XML_ELEMENT_DECL
	XML_ATTRIBUTE_DECL
	XML_ENTITY_DECL
	XML_NAMESPACE_DECL
	XML_XINCLUDE_START
	XML_XINCLUDE_END
	XML_DOCB_DOCUMENT_NODE
)

type Nodeset

type Nodeset []Node

func (Nodeset) ToPointers

func (n Nodeset) ToPointers() (pointers []unsafe.Pointer)

Produce a slice of unsafe.Pointer objects, suitable for passing to a C function

func (Nodeset) ToXPathNodeset

func (n Nodeset) ToXPathNodeset() (ret C.xmlXPathObjectPtr)

Produce a C.xmlXPathObjectPtr suitable for passing to libxml2

func (Nodeset) ToXPathValueTree

func (n Nodeset) ToXPathValueTree() (ret C.xmlXPathObjectPtr)

Produce a C.xmlXPathObjectPtr marked as a ResultValueTree, suitable for passing to libxml2

type ParseOption

type ParseOption int

ParseOption values allow you to tune the behaviour of the parsing engine.

const (
	XML_PARSE_RECOVER    ParseOption = 1 << iota // recover on errors
	XML_PARSE_NOENT                              // substitute entities
	XML_PARSE_DTDLOAD                            // load the external subset
	XML_PARSE_DTDATTR                            // default DTD attributes
	XML_PARSE_DTDVALID                           // validate with the DTD
	XML_PARSE_NOERROR                            // suppress error reports
	XML_PARSE_NOWARNING                          // suppress warning reports
	XML_PARSE_PEDANTIC                           // pedantic error reporting
	XML_PARSE_NOBLANKS                           // remove blank nodes
	XML_PARSE_SAX1                               // use the SAX1 interface internally
	XML_PARSE_XINCLUDE                           // Implement XInclude substitition
	XML_PARSE_NONET                              // Forbid network access
	XML_PARSE_NODICT                             // Do not reuse the context dictionnary
	XML_PARSE_NSCLEAN                            // remove redundant namespaces declarations
	XML_PARSE_NOCDATA                            // merge CDATA as text nodes
	XML_PARSE_NOXINCNODE                         // do not generate XINCLUDE START/END nodes
	XML_PARSE_COMPACT                            // compact small text nodes; makes tree read-only
	XML_PARSE_OLD10                              // parse using XML-1.0 before update 5
	XML_PARSE_NOBASEFIX                          // do not fixup XINCLUDE xml//base uris
	XML_PARSE_HUGE                               // relax any hardcoded limit from the parser
	XML_PARSE_OLDSAX                             // parse using SAX2 interface before 2.7.0
	XML_PARSE_IGNORE_ENC                         // ignore internal document encoding hint
	XML_PARSE_BIG_LINES                          // Store big lines numbers in text PSVI field
)

DefaultParseOption provides liberal parsing highly tolerant of invalid documents. Errors and warnings are suppressed and the DTD is not processed.

StrictParseOption provides standard-compliant parsing. The DTD is processed, entity substitions are made, and errors and warnings are reported back.

type ProcessingInstructionNode

type ProcessingInstructionNode struct {
	*XmlNode
}

type SerializationOption

type SerializationOption int

SerializationOption is a set of flags used to control how a node is written out.

const (
	XML_SAVE_FORMAT   SerializationOption = 1 << iota // format save output
	XML_SAVE_NO_DECL                                  //drop the xml declaration
	XML_SAVE_NO_EMPTY                                 //no empty tags
	XML_SAVE_NO_XHTML                                 //disable XHTML1 specific rules
	XML_SAVE_XHTML                                    //force XHTML1 specific rules
	XML_SAVE_AS_XML                                   //force XML serialization on HTML doc
	XML_SAVE_AS_HTML                                  //force HTML serialization on XML doc
	XML_SAVE_WSNONSIG                                 //format with non-significant whitespace
)

type TextNode

type TextNode struct {
	*XmlNode
}

func (*TextNode) DisableOutputEscaping

func (node *TextNode) DisableOutputEscaping()

DisableOutputEscaping disables the usual safeguards against creating invalid XML and allows the characters '<', '>', and '&' to be written out verbatim. Normally they are safely escaped as entities.

This API is intended to provide support for XSLT processors and similar XML manipulation libraries that may need to output unsupported entity references or use the XML API for non-XML output. It should never be used in the normal course of XML processing.

type WriteBuffer

type WriteBuffer struct {
	Node   *XmlNode
	Buffer []byte
	Offset int
}

type XmlDocument

type XmlDocument struct {
	Ptr *C.xmlDoc
	Me  Document
	Node
	InEncoding    []byte
	OutEncoding   []byte
	UnlinkedNodes map[*C.xmlNode]bool
	XPathCtx      *xpath.XPath
	Type          NodeType
	InputLen      int
	// contains filtered or unexported fields
}

XmlDocument is the primary interface for working with XML documents.

func CreateEmptyDocument

func CreateEmptyDocument(inEncoding, outEncoding []byte) (doc *XmlDocument)

Create an empty XML document and return an XmlDocument. The root element, along with any top-level comments or processing instructions, can be added by calling AddChild() on the document itself.

func NewDocument

func NewDocument(p unsafe.Pointer, contentLen int, inEncoding, outEncoding []byte) (doc *XmlDocument)

NewDocument wraps the pointer to the C struct.

TODO: this should probably not be exported.

func Parse

func Parse(content, inEncoding, url []byte, options ParseOption, outEncoding []byte) (doc *XmlDocument, err error)

Parse creates an XmlDocument from some pre-existing content where the input encoding is known. Byte arrays created from a Go string are utf-8 encoded (you can pass DefaultEncodingBytes in this scenario).

If you want to build up a document programmatically, calling CreateEmptyDocument and building it up using the xml.Node interface is a better approach than building a string and calling Parse.

If you have an XML file, then ReadFile will automatically determine the encoding according to the XML specification.

func ReadFile

func ReadFile(filename string, options ParseOption) (doc *XmlDocument, err error)

ReadFile loads an XmlDocument from a filename. The encoding declared in the document will be used as the input encoding. If no encoding is declared, the library will use the alogrithm in the XML standard to determine if the document is encoded with UTF-8 or UTF-16.

func (*XmlDocument) AddUnlinkedNode

func (document *XmlDocument) AddUnlinkedNode(nodePtr unsafe.Pointer)

func (*XmlDocument) BookkeepFragment

func (document *XmlDocument) BookkeepFragment(fragment *DocumentFragment)

func (*XmlDocument) CreateCDataNode

func (document *XmlDocument) CreateCDataNode(data string) (cdata *CDataNode)

CreateCDataNode creates a CDATA node. CDATA nodes can only be children of an element.

The data argument will become the content of the newly created node.

func (*XmlDocument) CreateCommentNode

func (document *XmlDocument) CreateCommentNode(data string) (comment *CommentNode)

CreateCommentNode creates a comment node. Comment nodes can be children of an element or of the document itself.

The data argument will become the content of the comment.

func (*XmlDocument) CreateElementNode

func (document *XmlDocument) CreateElementNode(tag string) (element *ElementNode)

CreateElementNode creates an element node with the specified tag name. It can be added as a child of any other element, or as a child of the document itself.

Use SetNamespace if the element node needs to be in a namespace.

Note that valid documents have only one child element, referred to as the root node.

func (*XmlDocument) CreatePINode

func (document *XmlDocument) CreatePINode(name, data string) (pi *ProcessingInstructionNode)

CreatePINode creates a processing instruction node with the specified name and data. Processing instruction nodes can be children of an element or of the document itself.

While it's common to use an attribute-like syntax for processing instructions, the data is actually an arbitrary string that you will need to generate or parse yourself.

func (*XmlDocument) CreateTextNode

func (document *XmlDocument) CreateTextNode(data string) (text *TextNode)

CreateTextNode creates a text node. It can be added as a child of an element.

The data argument is XML-escaped and used as the content of the node.

func (*XmlDocument) DocPtr

func (document *XmlDocument) DocPtr() (ptr unsafe.Pointer)

DocPtr provides access to the libxml2 structure underlying the document.

func (*XmlDocument) DocRef

func (document *XmlDocument) DocRef() (d Document)

DocRef returns the embedded Document interface.

func (*XmlDocument) DocType

func (document *XmlDocument) DocType() (t NodeType)

DocType returns one of the node type constants, usually XML_DOCUMENT_NODE. This may be of use if you are working with the C API.

func (*XmlDocument) DocXPathCtx

func (document *XmlDocument) DocXPathCtx() (ctx *xpath.XPath)

Returns an XPath context that can be used to compile and evaluate XPath expressions.

In most cases, you should call the Search or EvalXPath functions instead of handling the context directly.

func (*XmlDocument) Free

func (document *XmlDocument) Free()

Free the C structures associated with this document.

func (*XmlDocument) InputEncoding

func (document *XmlDocument) InputEncoding() (encoding []byte)

InputEncoding is the original encoding of the document.

func (*XmlDocument) NodeById

func (document *XmlDocument) NodeById(id string) (element *ElementNode)

Get an element node by the value of its ID attribute. By convention this attribute is named id, but the actual name of the attribute is set by the document's DTD or schema.

The value for an ID attribute is guaranteed to be unique within a valid document.

func (*XmlDocument) OutputEncoding

func (document *XmlDocument) OutputEncoding() (encoding []byte)

OutputEncoding is the encoding that will be used when the document is written out. This can be overridden by explicitly specifying an encoding as an argument to any of the output functions.

func (*XmlDocument) ParseFragment

func (document *XmlDocument) ParseFragment(input, url []byte, options ParseOption) (fragment *DocumentFragment, err error)

func (*XmlDocument) RemoveUnlinkedNode

func (document *XmlDocument) RemoveUnlinkedNode(nodePtr unsafe.Pointer) bool

func (*XmlDocument) Root

func (document *XmlDocument) Root() (element *ElementNode)

Root returns the root node of the document. Newly created documents do not have a root node until an element node is added a child of the document.

Documents that have multiple root nodes are invalid and the behaviour is not well defined.

func (*XmlDocument) UnparsedEntityURI

func (document *XmlDocument) UnparsedEntityURI(name string) (val string)

Return the value of an NDATA entity declared in the DTD. If there is no such entity or the value cannot be encoded as a valid URI, an empty string is returned.

Note that this library assumes you already know the name of entity and does not expose any way of getting the list of entities.

func (*XmlDocument) Uri

func (document *XmlDocument) Uri() (val string)
Uri returns the URI of the document - typically this is the filename if ReadFile was used to parse

the document.

type XmlNode

type XmlNode struct {
	Ptr *C.xmlNode
	Document
	// contains filtered or unexported fields
}

XmlNode implements the Node interface, and as such is the heart of the API.

func (*XmlNode) AddChild

func (xmlNode *XmlNode) AddChild(data interface{}) (err error)

Add a node as a child of the current node. Passing in a nodeset will add all the nodes as children of the current node.

func (*XmlNode) AddNextSibling

func (xmlNode *XmlNode) AddNextSibling(data interface{}) (err error)

Insert a node immediately after this node in the document. Passing in a nodeset will add all the nodes, in order.

func (*XmlNode) AddPreviousSibling

func (xmlNode *XmlNode) AddPreviousSibling(data interface{}) (err error)

Insert a node immediately before this node in the document. Passing in a nodeset will add all the nodes, in order.

func (*XmlNode) Attr

func (xmlNode *XmlNode) Attr(name string) (val string)

Attr returns the value of an attribute.

If you need to check for the existence of an attribute, use Attribute.

func (*XmlNode) Attribute

func (xmlNode *XmlNode) Attribute(name string) (attribute *AttributeNode)

Return the attribute node, or nil if the attribute does not exist.

func (*XmlNode) AttributeList

func (xmlNode *XmlNode) AttributeList() (attributes []*AttributeNode)

Return a document-ordered list of attribute nodes.

func (*XmlNode) Attributes

func (xmlNode *XmlNode) Attributes() (attributes map[string]*AttributeNode)

Return the attribute nodes indexed by name.

func (*XmlNode) Coerce

func (xmlNode *XmlNode) Coerce(data interface{}) (nodes []Node, err error)

func (*XmlNode) Content

func (xmlNode *XmlNode) Content() string

func (*XmlNode) CountChildren

func (xmlNode *XmlNode) CountChildren() int

CountChildren returns the number of child nodes.

func (*XmlNode) DeclareNamespace

func (xmlNode *XmlNode) DeclareNamespace(prefix, href string)

Add a namespace declaration to an element.

This is typically done on the root element or node high up in the tree to avoid duplication. The declaration is not created if the namespace is already declared in this scope with the same prefix.

func (*XmlNode) DeclaredNamespaces

func (xmlNode *XmlNode) DeclaredNamespaces() (result []NamespaceDeclaration)

Returns a list of all the namespace declarations that exist on this node.

You can add a namespace declaration by calling DeclareNamespace. Calling SetNamespace will automatically add a declaration if required.

Calling SetNsAttr does *not* automatically create a declaration. This will fixed in a future version.

func (*XmlNode) Duplicate

func (xmlNode *XmlNode) Duplicate(level int) Node

func (*XmlNode) DuplicateTo

func (xmlNode *XmlNode) DuplicateTo(doc Document, level int) (dup Node)

func (*XmlNode) EvalXPath

func (xmlNode *XmlNode) EvalXPath(data interface{}, v xpath.VariableScope) (result interface{}, err error)

Evaluate an XPath and return a result of the appropriate type. If a non-nil VariableScope is provided, any variables or functions present in the xpath will be resolved.

If the result is a nodeset (or the empty nodeset), a nodeset will be returned.

If the result is a number, a float64 will be returned.

If the result is a boolean, a bool will be returned.

In any other cases, the result will be coerced to a string.

func (*XmlNode) EvalXPathAsBoolean

func (xmlNode *XmlNode) EvalXPathAsBoolean(data interface{}, v xpath.VariableScope) (result bool)

Evaluate an XPath and coerce the result to a boolean according to the XPath rules. In the presence of an error, this function will return false even if the expression cannot actually be evaluated.

In most cases you are better advised to call EvalXPath; this function is intended for packages that implement XML standards and that are fully aware of the consequences of suppressing a compilation error.

If a non-nil VariableScope is provided, any variables or registered functions present in the xpath will be resolved.

func (*XmlNode) FirstChild

func (xmlNode *XmlNode) FirstChild() Node

func (*XmlNode) InnerHtml

func (xmlNode *XmlNode) InnerHtml() string

func (*XmlNode) InsertAfter

func (xmlNode *XmlNode) InsertAfter(data interface{}) (err error)

func (*XmlNode) InsertBefore

func (xmlNode *XmlNode) InsertBefore(data interface{}) (err error)

func (*XmlNode) InsertBegin

func (xmlNode *XmlNode) InsertBegin(data interface{}) (err error)

func (*XmlNode) InsertEnd

func (xmlNode *XmlNode) InsertEnd(data interface{}) (err error)

func (*XmlNode) IsValid

func (xmlNode *XmlNode) IsValid() bool

Returns true if the node is valid. Nodes become invalid when Remove() is called.

func (*XmlNode) LastChild

func (xmlNode *XmlNode) LastChild() Node

func (*XmlNode) LineNumber

func (xmlNode *XmlNode) LineNumber() int

Returns the line number on which the node appears, or a -1 if the line number cannot be determined.

func (*XmlNode) MyDocument

func (xmlNode *XmlNode) MyDocument() (document Document)

Return the document containing this node. Removed or unlinked nodes still have a document associated with them.

func (*XmlNode) Name

func (xmlNode *XmlNode) Name() (name string)

The local name of the node. Use Namespace() to get the namespace.

func (*XmlNode) Namespace

func (xmlNode *XmlNode) Namespace() (href string)

The namespace of the node. This is the empty string if there no associated namespace.

func (*XmlNode) NextSibling

func (xmlNode *XmlNode) NextSibling() Node

NextSibling returns the next sibling (if any) of the current node. It is often used when iterating over the children of a node.

func (*XmlNode) NodePtr

func (xmlNode *XmlNode) NodePtr() (p unsafe.Pointer)

NodePtr returns a pointer to the underlying C struct.

func (*XmlNode) NodeType

func (xmlNode *XmlNode) NodeType() (nodeType NodeType)

func (*XmlNode) Parent

func (xmlNode *XmlNode) Parent() Node

Parent returns the parent of the current node (or nil if there isn't one). This will always be an element or document node, as those are the only node types that can have children.

func (*XmlNode) ParseFragment

func (xmlNode *XmlNode) ParseFragment(input, url []byte, options ParseOption) (fragment *DocumentFragment, err error)

func (*XmlNode) Path

func (xmlNode *XmlNode) Path() (path string)

Path returns an XPath expression that can be used to select this node in the document.

func (*XmlNode) PreviousSibling

func (xmlNode *XmlNode) PreviousSibling() Node

PreviousSibling returns the previous sibling (if any) of the current node. It is often used when iterating over the children of a node in reverse.

func (*XmlNode) RecursivelyRemoveNamespaces

func (xmlNode *XmlNode) RecursivelyRemoveNamespaces() (err error)

func (*XmlNode) Remove

func (xmlNode *XmlNode) Remove()

func (*XmlNode) RemoveDefaultNamespace

func (xmlNode *XmlNode) RemoveDefaultNamespace()

func (*XmlNode) Replace

func (xmlNode *XmlNode) Replace(data interface{}) (err error)

func (*XmlNode) ResetChildren

func (xmlNode *XmlNode) ResetChildren()

func (*XmlNode) ResetNodePtr

func (xmlNode *XmlNode) ResetNodePtr()

func (*XmlNode) Search

func (xmlNode *XmlNode) Search(data interface{}) (result []Node, err error)

Search for nodes that match an XPath. This is the simplest way to look for nodes.

func (*XmlNode) SearchWithVariables

func (xmlNode *XmlNode) SearchWithVariables(data interface{}, v xpath.VariableScope) (result []Node, err error)

As the Search function, but passing a VariableScope that can be used to reolve variable names or registered function references in the XPath being evaluated.

func (*XmlNode) SerializeWithFormat

func (xmlNode *XmlNode) SerializeWithFormat(format SerializationOption, encoding, outputBuffer []byte) ([]byte, int)

SerializeWithFormat allows you to control the serialization flags passed to libxml. In most cases ToXml() and ToHtml() provide sensible defaults and should be preferred.

The format parameter should be a set of SerializationOption constants or'd together. If encoding is nil, the document's output encoding is used - this defaults to UTF-8. If outputBuffer is nil, one will be created for you.

func (*XmlNode) SetAttr

func (xmlNode *XmlNode) SetAttr(name, value string) (val string)

SetAttr sets the value of an attribute. If the attribute is in a namespace, use SetNsAttr instead.

While this call accepts QNames for the name parameter, it does not check their validity.

Attributes such as "xml:lang" or "xml:space" are not is a formal namespace and should be set by calling SetAttr with the prefix as part of the name.

func (*XmlNode) SetChildren

func (xmlNode *XmlNode) SetChildren(data interface{}) (err error)

func (*XmlNode) SetContent

func (xmlNode *XmlNode) SetContent(content interface{}) (err error)

func (*XmlNode) SetInnerHtml

func (xmlNode *XmlNode) SetInnerHtml(data interface{}) (err error)

func (*XmlNode) SetName

func (xmlNode *XmlNode) SetName(name string)

Set the local name of the node. The namespace is set via SetNamespace().

func (*XmlNode) SetNamespace

func (xmlNode *XmlNode) SetNamespace(prefix, href string)

Set the namespace of an element.

func (*XmlNode) SetNsAttr

func (xmlNode *XmlNode) SetNsAttr(href, name, value string) (val string)

SetNsAttr sets the value of a namespaced attribute.

Attributes such as "xml:lang" or "xml:space" are not is a formal namespace and should be set by calling SetAttr with the xml prefix as part of the name.

The namespace should already be declared and in-scope when SetNsAttr is called. This restriction will be lifted in a future version.

func (*XmlNode) String

func (xmlNode *XmlNode) String() string

func (*XmlNode) ToBuffer

func (xmlNode *XmlNode) ToBuffer(outputBuffer []byte) []byte

func (*XmlNode) ToHtml

func (xmlNode *XmlNode) ToHtml(encoding, outputBuffer []byte) ([]byte, int)

ToHtml generates an indented XML document that conforms to HTML 4.0 rules; meaning that some elements may be unclosed or forced to use end tags even when empty.

If you want to output XHTML, call SerializeWithFormat and enable the XML_SAVE_XHTML flag as part of the format.

If encoding is nil, the document's output encoding is used - this defaults to UTF-8. If outputBuffer is nil, one will be created for you.

func (*XmlNode) ToUnformattedXml

func (xmlNode *XmlNode) ToUnformattedXml() string

ToUnformattedXml generates an unformatted XML document without an XML declaration. This is useful for conforming to various standards and for unit testing, although the output is not guaranteed to be well formed unless xmlNode is an element node.

func (*XmlNode) ToXml

func (xmlNode *XmlNode) ToXml(encoding, outputBuffer []byte) ([]byte, int)

ToXml generates an indented XML document with an XML declaration. It is not guaranteed to be well formed unless xmlNode is an element node, or a document node with only one element child.

If you need finer control over the formatting, call SerializeWithFormat.

If encoding is nil, the document's output encoding is used - this defaults to UTF-8. If outputBuffer is nil, one will be created for you.

func (xmlNode *XmlNode) Unlink()

func (*XmlNode) Wrap

func (xmlNode *XmlNode) Wrap(data string) (err error)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL