Reference

An XML/HTML document type.

A proxy type to libxml2's node struct.

Properties

A streaming XML reader type.

An error detected by libxml2.

parsexml(xmlstring; options...)

Parse xmlstring and create an XML document.

Parsing Options

• noerror = false: suppress (recoverable) error reports
• nowarning = false: suppress warning reports
• pedantic = false: pedantic error reporting
• noblanks = false: remove blank nodes

parsehtml(htmlstring; options...)

Parse htmlstring and create an HTML document.

See parsexml for parsing options.

readxml(filename; options...)

Read filename and create an XML document.

See parsexml for parsing options.

readxml(input::IO; options...)

Read input and create an XML document.

See parsexml for parsing options.

readhtml(filename; options...)

Read filename and create an HTML document.

See parsexml for parsing options.

readhtml(input::IO; options...)

Read input and create an HTML document.

See parsexml for parsing options.

prettyprint([io], node::Node)

Print node with formatting.

prettyprint([io], doc::Document)

Print doc with formatting.

XMLDocument(version="1.0")

Create an XML document.

HTMLDocument(uri=nothing, externalID=nothing)

Create an HTML document.

XMLDocumentNode(version)

Create an XML document node with version.

HTMLDocumentNode(uri, externalID)

Create an HTML document node.

uri and externalID are either a string or nothing.

ElementNode(name)

Create an element node with name.

TextNode(content)

Create a text node with content.

CommentNode(content)

Create a comment node with content.

CDataNode(content)

Create a CDATA node with content.

AttributeNode(name, value)

Create an attribute node with name and value.

DTDNode(name, [systemID, [externalID]])

Create a DTD node with name, systemID, and externalID.

nodetype(node::Node)

Return the type of node as an integer.

nodepath(node::Node)

Return the path of node.

nodename(node::Node)

Return the node name of node.

nodecontent(node::Node)

Return the node content of node.

namespace(node::Node)

Return the namespace associated with node.

namespaces(node::Node)

Create a vector of namespaces applying to node.

hasnodename(node::Node)

Return if node has a node name.

hasnamespace(node::Node)

Return if node is associated with a namespace.

iselement(node::Node)

Return if node is an element node.

isattribute(node::Node)

Return if node is an attribute node.

istext(node::Node)

Return if node is a text node.

iscdata(node::Node)

Return if node is a CDATA node.

iscomment(node::Node)

Return if node is a comment node.

isdtd(node::Node)

Return if node is a DTD node.

countnodes(parent::Node)

Count the number of child nodes of parent.

countelements(parent::Node)

Count the number of child elements of parent.

countattributes(elem::Node)

Count the number of attributes of elem.

systemID(node::Node)

Return the system ID of node.

externalID(node::Node)

Return the external ID of node.

setnodename!(node::Node, name::AbstractString)

Set the name of node.

setnodecontent!(node::Node, content::AbstractString)

Replace the content of node.

version(doc::Document)

Return the version string of doc.

encoding(doc::Document)

Return the encoding string of doc.

hasversion(doc::Document)

Return if doc has a version string.

hasencoding(doc::Document)

Return if doc has an encoding string.

document(node::Node)

Return the document of node.

root(doc::Document)

Return the root element of doc.

dtd(doc::Document)

Return the DTD node of doc.

parentnode(node::Node)

Return the parent of node.

parentelement(node::Node)

Return the parent element of node.

firstnode(node::Node)

Return the first child node of node.

lastnode(node::Node)

Return the last child node of node.

firstelement(node::Node)

Return the first child element of node.

lastelement(node::Node)

Return the last child element of node.

nextnode(node::Node)

Return the next node of node.

prevnode(node::Node)

Return the previous node of node.

nextelement(node::Node)

Return the next element of node.

prevelement(node::Node)

Return the previous element of node.

eachnode(node::Node, [backward=false])

Create an iterator of child nodes.

nodes(node::Node, [backward=false])

Create a vector of child nodes.

eachelement(node::Node, [backward=false])

Create an iterator of child elements.

elements(node::Node, [backward=false])

Create a vector of child elements.

eachattribute(node::Node)

Create an iterator of attributes.

eachattribute(reader::StreamReader)

Return an AttributeReader object for the current node of reader

attributes(node::Node)

Create a vector of attributes.

hasroot(doc::Document)

Return if doc has a root element.

hasdtd(doc::Document)

Return if doc has a DTD node.

hasnode(node::Node)

Return if node has a child node.

hasnextnode(node::Node)

Return if node has a next node.

hasprevnode(node::Node)

Return if node has a previous node.

haselement(node::Node)

Return if node has a child element.

hasnextelement(node::Node)

Return if node has a next node.

hasprevelement(node::Node)

Return if node has a previous node.

hasdocument(node::Node)

Return if node belongs to a document.

hasparentnode(node::Node)

Return if node has a parent node.

hasparentelement(node::Node)

Return if node has a parent node.

setroot!(doc::Document, node::Node)

Set the root element of doc to node and return the root element.

setdtd!(doc::Document, node::Node)

Set the DTD node of doc to node and return the DTD node.

link!(parent::Node, child::Node)

Link child at the end of children of parent.

linknext!(target::Node, node::Node)

Link node as the next sibling of target.

linkprev!(target::Node, node::Node)

Link node as the prev sibling of target.

unlink!(node::Node)

Unlink node from its context.

addelement!(parent::Node, name::AbstractString)

Add a new child element of name with no content to parent and return the new child element.

addelement!(parent::Node, name::AbstractString, content::AbstractString)

Add a new child element of name with content to parent and return the new child element.

findall(xpath::AbstractString, doc::Document)

Find nodes matching xpath XPath query from doc.

findfirst(xpath::AbstractString, doc::Document)

Find the first node matching xpath XPath query from doc.

findlast(doc::Document, xpath::AbstractString)

Find the last node matching xpath XPath query from doc.

findall(xpath::AbstractString, node::Node, [ns=namespaces(node)])

Find nodes matching xpath XPath query starting from node.

The ns argument is an iterator of namespace prefix and URI pairs.

findfirst(xpath::AbstractString, node::Node, [ns=namespaces(node)])

Find the first node matching xpath XPath query starting from node.

findlast(node::Node, xpath::AbstractString, [ns=namespaces(node)])

Find the last node matching xpath XPath query starting from node.

validate(doc::Document, [dtd::Node])

Validate doc against dtd and return the validation log.

The validation log is empty if and only if doc is valid. The DTD node in doc will be used if dtd is not passed.

readdtd(filename::AbstractString)

Read filename and create a DTD node.

expandtree(reader::StreamReader)

Expand the current node of reader into a full subtree that will be available until the next read of node.

Note that the expanded subtree is a read-only and temporary object. You cannot modify it or keep references to any nodes of it after reading the next node.

Currently, namespace functions and XPath query will not work on the expanded subtree.

nodetype(reader::StreamReader)

Return the type of the current node of reader.

nodename(reader::StreamReader)

Return the name of the current node of reader.

nodecontent(reader::StreamReader)

Return the content of the current node of reader.

nodedepth(reader::StreamReader)

Return the depth of the current node of reader.

namespace(reader::StreamReader)

Return the namespace of the current node of reader.

hasnodecontent(reader::StreamReader)

Return if the current node of reader has content.

hasnodename(reader::StreamReader)

Return if the current node of reader has a node name.