Free xml document software for linux

XML::DOM::Document is an XML document node in XML::DOM.

XML::DOM::Document extends XML::DOM::Node.

It is the main root of the XML document structure as returned by XML::DOM::Parser::parse and XML::DOM::Parser::parsefile.

Since elements, text nodes, comments, processing instructions, etc. cannot exist outside the context of a Document, the Document interface also contains the factory methods needed to create these objects. The Node objects created have a getOwnerDocument method which associates them with the Document within whose context they were created.

METHODS

getDocumentElement

This is a convenience method that allows direct access to the child node that is the root Element of the document.

getDoctype

The Document Type Declaration (see DocumentType) associated with this document. For HTML documents as well as XML documents without a document type declaration this returns undef. The DOM Level 1 does not support editing the Document Type Declaration.

Not In DOM Spec: This implementation allows editing the doctype. See XML::DOM::ignoreReadOnly for details.

getImplementation

The DOMImplementation object that handles this document. A DOM application may use objects from multiple implementations.

createElement (tagName)

Creates an element of the type specified. Note that the instance returned implements the Element interface, so attributes can be specified directly on the returned object.

DOMExceptions:

INVALID_CHARACTER_ERR

Raised if the tagName does not conform to the XML spec.

createTextNode (data)

Creates a Text node given the specified string.

createComment (data)

Creates a Comment node given the specified string.

createCDATASection (data)

Creates a CDATASection node given the specified string.

createAttribute (name [, value [, specified ]])

Creates an Attr of the given name. Note that the Attr instance can then be set on an Element using the setAttribute method.

Not In DOM Spec: The DOM Spec does not allow passing the value or the specified property in this method. In this implementation they are optional.

Parameters: value The attributes value. See Attr::setValue for details. If the value is not supplied, the specified property is set to 0. specified Whether the attribute value was specified or whether the default value was used. If not supplied, its assumed to be 1.

DOMExceptions:

INVALID_CHARACTER_ERR

Raised if the name does not conform to the XML spec.

createProcessingInstruction (target, data)

Creates a ProcessingInstruction node given the specified name and data strings.

Parameters: target The target part of the processing instruction. data The data for the node.

DOMExceptions:

INVALID_CHARACTER_ERR

Raised if the target does not conform to the XML spec.

createDocumentFragment

Creates an empty DocumentFragment object.

createEntityReference (name)

Creates an EntityReference object.

XML::DOM::DocumentType is an XML document type (DTD) in XML::DOM.

XML::DOM::DocumentType extends XML::DOM::Node.

Each Document has a doctype attribute whose value is either null or a DocumentType object. The DocumentType interface in the DOM Level 1 Core provides an interface to the list of entities that are defined for the document, and little else because the effect of namespaces and the various XML scheme efforts on DTD representation are not clearly understood as of this writing. The DOM Level 1 doesnt support editing DocumentType nodes.

Not In DOM Spec: This implementation has added a lot of extra functionality to the DOM Level 1 interface. To allow editing of the DocumentType nodes, see XML::DOM::ignoreReadOnly.

XML::Descent is a Perl module for recursive descent XML parsing.

SYNOPSIS

use XML::Descent;

# Create parser
my $p = XML::Descent->new({
Input => $xml
});

# Setup handlers
$p->on(folder => sub {
my ($elem, $attr) = @_;

$p->on(url => sub {
my ($elem, $attr) = @_;
my $link = {
name => $attr->{name},
url => $p->text()
};
$p->stash(link => $link);
});

my $folder = $p->walk();
$folder->{name} = $attr->{name};

$p->stash(folder => $folder);
});

# Parse
my $res = $p->walk();

The conventional models for parsing XML are either DOM (a data structure representing the entire document tree is created) or SAX (callbacks are issued for each element in the XML).

XML grammar is recursive - so its nice to be able to write recursive parsers for it. XML::Descent allows such parsers to be created.

Typically a new XML::Descent is created and handlers are defined for elements were interested in

my $p = XML::Descent->new({ Input => $xml });
$p->on(link => sub {
my ($elem, $attr) = @_;
print "Found link: ", $attr->{url}, "n";
$p->walk(); # recurse
});
$p->walk(); # parse

A handler provides a convenient lexical scope that lasts until the closing tag of the element that triggered the handler is reached.

When called at the top level the parsing methods walk(), text() and xml() parse the whole XML document. When called recursively within a handler they parse the portion of the document nested inside node that triggered the handler.

New handlers may be defined within a handler and their scope will be limited to the XML inside the node that triggered the handler.

XML::DOM is a perl module for building DOM Level 1 compliant document structures.

SYNOPSIS

use XML::DOM;

my $parser = new XML::DOM::Parser;
my $doc = $parser->parsefile ("file.xml");

# print all HREF attributes of all CODEBASE elements
my $nodes = $doc->getElementsByTagName ("CODEBASE");
my $n = $nodes->getLength;

for (my $i = 0; $i < $n; $i++)
{
my $node = $nodes->item ($i);
my $href = $node->getAttributeNode ("HREF");
print $href->getValue . "n";
}

# Print doc file
$doc->printToFile ("out.xml");

# Print to string
print $doc->toString;

# Avoid memory leaks - cleanup circular references for garbage collection
$doc->dispose;

This module extends the XML::Parser module by Clark Cooper. The XML::Parser module is built on top of XML::Parser::Expat, which is a lower level interface to James Clarks expat library.

XML::DOM::Parser is derived from XML::Parser. It parses XML strings or files and builds a data structure that conforms to the API of the Document Object Model as described at http://www.w3.org/TR/REC-DOM-Level-1. See the XML::Parser manpage for other available features of the XML::DOM::Parser class. Note that the Style property should not be used (it is set internally.)

The XML::Parser NoExpand option is more or less supported, in that it will generate EntityReference objects whenever an entity reference is encountered in character data. Im not sure how useful this is. Any comments are welcome.

As described in the synopsis, when you create an XML::DOM::Parser object, the parse and parsefile methods create an XML::DOM::Document object from the specified input. This Document object can then be examined, modified and written back out to a file or converted to a string.

When using XML::DOM with XML::Parser version 2.19 and up, setting the XML::DOM::Parser option KeepCDATA to 1 will store CDATASections in CDATASection nodes, instead of converting them to Text nodes. Subsequent CDATASection nodes will be merged into one. Let me know if this is a problem.
When using XML::Parser 2.27 and above, you can suppress expansion of parameter entity references (e.g. %pent;) in the DTD, by setting ParseParamEnt to 1 and ExpandParamEnt to 0. See Hidden Nodes for details.

A Document has a tree structure consisting of Node objects. A Node may contain other nodes, depending on its type. A Document may have Element, Text, Comment, and CDATASection nodes. Element nodes may have Attr, Element, Text, Comment, and CDATASection nodes. The other nodes may not have any child nodes.

This module adds several node types that are not part of the DOM spec (yet.) These are: ElementDecl (for < !ELEMENT ... > declarations), AttlistDecl (for < !ATTLIST ... > declarations), XMLDecl (for < ?xml ...? > declarations) and AttDef (for attribute definitions in an AttlistDecl.)

XML::DOM::Node is a super class of all nodes in XML::DOM.

XML::DOM::Node is the super class of all nodes in an XML::DOM document. This means that all nodes that subclass XML::DOM::Node also inherit all the methods that XML::DOM::Node implements.

GLOBAL VARIABLES

@NodeNames

The variable @XML::DOM::Node::NodeNames maps the node type constants to strings. It is used by XML::DOM::Node::getNodeTypeName.

XML::DOM::XMLDecl is a XML declaration in XML::DOM.

XML::DOM::XMLDecl extends XML::DOM::Node, but is not part of the DOM Level 1 specification.

It contains the XML declaration, e.g.

< ?xml version="1.0" encoding="UTF-16" standalone="yes"? >

See also XML::DOM::Document::getXMLDecl.

METHODS

getVersion and setVersion (version)

Returns and sets the XML version. At the time of this writing the version should always be "1.0"

getEncoding and setEncoding (encoding)

undef may be specified for the encoding value.

getStandalone and setStandalone (standalone)

undef may be specified for the standalone value.