NAME
xml - standard xml module
XML PARSING
This chapter is dedicated to the AFNIX XML parsing, a subpart of the
standard xml processing module. XML parsing refers to the ability to
read valid xml constructs from an input stream and build an internal
representation that is suitable for later processing. This chapter is
designed for handling basic XML representation and does not cover the
operations performed by a XML processor, such like entity expansion or
DTD validation. All AFNIX xml processing objects are located in the
afnix-xml module. This module must be loaded prior any operation.
Multiple calls to the module initialization routine are harmless. The
interpreter method library loads a specific module by name. When the
module has been loaded, the object are available in the afnix:xml
nameset.
interp:library "afnix-xml"
XML tree representation
A xml document is represented with a tree. At the top of the tree is
the XmlRoot object. The root object is not part of the document, but
acts as the primary container for other objects. Inside AFNIX , a xml
document starts with a root node and all other child elements are
XmlNode objects.
Node base object
The xml tree is built with the XmlNode object. The node object has
different derivation depending on the required representation. For
example, the XmlRoot object is derived from the XmlNode object. A node
object can have child object unless the node is marked as an empty
node. Trying to add node to an empty node results in an exception. A
node can also be marked empty by the user. This situation typically
arises with tag node which are used alone such like the <br/> xhtml
empty tag or an empty paragraph <p/>. Although a xml node cannot be
constructed directly, there is a predicate node-p that can be used to
assert the node type.
# check a node
assert true (afnix:xml:node-p node)
The add-child method adds a child node to the calling node. If the
calling node is marked empty, an exception is raised when attempting to
add the node. There is no limit for the number of nodes to add. In
particular, when a text is to be added, care should be taken that there
is no markup within that text. In doubt, the parse method should be
used.
# parse a text and add 3 child nodes
p:parse "The quick brown <b>fox</b> jumps over the lazy dog"
In the previous example, the first child node is a XmlText node with
the value The quick brown . The second node is a XmlTag node with name
b. Finally, the third node is also a XmlText node with the value jumps
over the lazy dog. It should be noted that the tag node has a child
XmlText node with the value fox. This example also illustrates the
power of the parse method which considerably simplify the creation of a
xml tree. Finally, there is a subtle subject to be treated later which
concerns the use of character reference with the parse method. Like any
other xml parser, character references are evaluated during the parsing
phase, thus providing no mechanism to create such reference. For this
reason, a special class called XmlCref is provided in the module.
Tag object
The XmlTag class is one of the most important class as it holds most of
the xml constructs. A tag is defined by a name, a set of attributes and
eventually a content. In its simplest form, a tag is created by name.
With an additional boolean parameter, the tag can be marked as an empty
node.
# create an empty paragraph tag
const p (afnix:xml:XmlTag "p" true)
Adding attributes to a tag is imply a matter of method call. The add-
attribute method operates with a Property object while the set-
attribute operates with a name and a literal value. As a matter of
fact, the attributes are stored internally as a property list.
# <p class="text">
# create a paragraph tag
const p (afnix:xml:XmlTag "p")
# set the class attribute
p:set-attribute "class" "text"
The node empty flag determines whether or not there is a end tag
associated with a tag. If the empty flag is false, the node can have
children nodes and is associated with a end tag. With the empty flag
set, there is no child nodes. Such situation corresponds to the xml />
notation.
# <br/>
# create a br empty tag
const br (afnix:xml:XmlTag "br" true)
Text objects
The xml module provides two types of xml text node. The basic object is
the XmlText node which is designed to hold some text without markup. It
is this kind of nodes which is automatically instantiated by the parse
method, as described earlier. The other object is the XmlData which
corresponds to the xml CDATA special markup. With a character data
node, the characters are not interpreted, including those that indicate
markup starts like < or end like >. The XmlData is particularly used to
store scripts or other program text inside a xml description. As an
example, it is recommended to use a character data node inside a script
tag with xhtml.
Document reading
A xml document is read by scanning an input stream an building a
representation of the xml tree.
The document object
The XmlDocument object is a special object is designed to ease the
reading process of an xml document. The process of creating a xml
document consists of creating a document object, then binding a xml
reader, parsing the input stream and finally storing the root node.
When the operation is completed, the root node is available in the
document object.
# create a xml document
const xdoc (afnix:xml:XmlDocument "example.xml")
# get the root node
const rppt (xdoc:get-root)
The root node content
When a document is parsed, the root node holds all the elements and
markup sequentially. At this stage, it shall be noted that the element
data are not expanded. Unlike a normal XML reader, the parameter entity
are kept in the node data, are expended later by the XML processor.
XML NODE ENGINE
This chapter is dedicated to the AFNIX XML node engine (xne), a
subpart of the standard xml processing module. The XML node engine is
designed to manipulate the node tree as well as searching for nodes.
Node tree operations
The class XneTree provides a single framework to operate on a node and
its associated tree. Since a node always carries a subtree, this
chapter will refer to it as the node tree.
Creating a node tree
A node tree is created either from a node at construction or with the
help of the set-node method.
# create a node tree at construction
const tree (afnix:xml:XneTree root)
# change the node tree
tree:set-node node
Once a tree is created, various methods are provided to operate on the
whole tree. The depth method returns the depth of the node tree. The
get-node methods returns the the node associated with the tree.
# get the tree depth
println (tree:depth)
Namespace operations
The concept of namespace is an extension to the xml standard. Unlike
other programming language, the concept of namespace is designed to
establish a binding between a name and an uri. Such binding permits to
establish a scope for tags without too much burden. In the xml
namespace terminology, an expanded name is composed of a prefix and a
local name. The basic operations provided at the tree level is the
prefix cancellation and the tree prefix setting.
# clear the prefix for the whole tree
tree:clear-prefix
# set a prefix for the whole tree
tree:set-prefix "afnix"
The set-prefix changes the prefix for the whole tree. It is not
necessary to clear first the prefix.
Attribute operations
Each node in the node tree can have its attribute list modified in a
single operation. The first operation is to clear all attributes for
all nodes. Although this operation might be useful, it should be
carried with caution. The attributes can also cleared more selectively
by using the tag name as a filter. For more complex operation, the
clear-attribute method of the XmlTag is the definitive answer.
# clear all attributes
tree:clear-attribute
# clear all attributes by tag name
tree:clear-attribute "p"
The set-attribute method sets an attribute to the whole tree. The first
argument is the attribute name and the second is a literal value. For
more selective operations, the set-attribute method can be also called
at the tag level.
# clear all attributes
tree:set-attribute "class" "text"
When it comes to set attributes, there is a special operation related
to the "id" attribute. Such attribute is supposed to be unique for the
whole tree. For this reason, the generate-id generates a unique id for
each node and assign the id attribute. The attribute is unique at the
time of the call. If the tree is modified, and in particular, if new
node are added, the method must be called again to regenerate the node
id.
# set a unique id for all nodes
tree:generate-id
Node location and searching
The node location is the ability to locate one or several nodes in a
xml tree. A node is generally located by name, path or id. Once a node
has been located, it can be processed. Note that the node locator
operates operates almost exclusively with XmlTag node, although it
might not be always the case.
Node selection
The process of finding a child node is obtained with the help of the
XneCond class combined with the select method of the XneTree Object.
The select method traverses the whole tree and attempts to match a
condition for each node. If the condition is evaluated successfully for
a node, the node is added in the result vector. Note that the tree can
be traversed entirely or with only the filar layer of children.
# creating a condition node
const xcnd (afnix:xml:XneCond)
# create a tree with a root node
const tree (afnix:xml:XneTree root)
# select all nodes for that condition
trans result (tree:select xcnd)
In the previous example, the condition object is empty. This means that
there is no condition, and thus wowrks for all nodes. This previous
example will return all nodes in the tree.
Node condition
The XmlCond class provides several method to add a conditions. The add
method is the method of choice to add a condition. The method operates
with a condition type and a literal. Note that the object can contain
several conditions.
# creating a condition node
const xcnd (afnix:xml:XneCond)
# add a condition by name
xcnd:add afnix:xml:xne:NAME "p"
In the previous example, a condition is designed to operate with a tag
name. Upon a call to the select method with this condition, all nodes
in the tree that have the tag name p will be selected.
# creating a condition node
const xcnd (afnix:xml:XneCond)
# add a condition by name
xcnd:add afnix:xml:xne:NAME "p"
# add an index condition
xcnd:add afnix:xml:xne:INDEX 0
In the previous example, a condition is designed to operate with a tag
name and index. Upon a call to the select method with this condition,
all nodes in the tree that have the tag name p and those child index is
0 will be selected.
Selection result
The node selection operates by default on the whole tree. The select
method, when called with a second boolean argument can rstrict the
search to the child nodes.
# creating a condition node
const xcnd (afnix:xml:XneCond)
# create a tree with a root node
const tree (afnix:xml:XneTree root)
# select all nodes for that condition
trans result (tree:select xcnd false)
The selection results is stored in a vector object. The node order
corresponds to the tree order obtained with a depth first search
approach.
XML NODE ENGINE
This chapter is dedicated to the AFNIX XML simple model (xsm), a
subpart of the standard xml processing module. The XML simple model is
designed to simplify the interpretation of a general sgml document such
like, html or xhtml document. In the simple model approach, there is no
tree. Instead, a vector of simple nodes is built, and a document
interface can be used to access the nodes. Therefore, this simple model
should be considered as a mean to quickly parse document, but should
not be used when tree operations come into play. In such case, the xml
model is by far more appropriate. The simple model can be used to parse
a html document for instance. Nore also that the simple model is a
relaxed model in terms of parsing rules. For example, the tag start/end
consistency is not checked and the attribute parsing is not aggressive
as it can be found generaly in poorly written html document.
Simple model node
In the simple model, a XsmNode is just a text place holder. The node
transports its type which can be either text, tag, reference of end
node. For the tag node, a subtype that identifies reserved nodes versus
normal type is also available.
Creating a node
A xsm node is created by name or byte and name. In the first case, the
node is a text node. In the second case, the node subtype is
automatically detected for tag node.
# create a xsm text node
const ntxt (afnix:xml:XsmNode "afnix">
# create a xsm tag node
const ntag (afnix:xml:XsmNode afnix:xml:XsmNode:TAG "afnix">
Note that the text corresponds to the node content. For example, the
string "!-- example --" might corresponds to a comment in html which is
to say a reserved tag when the type is tag or a simple text if the type
is a text node. A reserved tag is defined by a string which start
either with the ’!’ character or the ’[’ character.
# create a reserved tag
const rtag (afnix:xml:XsmNode afnix:xml:XsmNode:TAG "!-- example --")
Node representation
The xsm node is a literal node. This means that the to-string and to-
literal methods are available. When the to-literal method is called,
the node text is automatically formatted to reflect the node type.
# create a reserved tag
const rtag (afnix:xml:XsmNode afnix:xml:XsmNode:TAG "!-- example --")
# print the node literal
rtag:to-literal # <!-- example -->
If the node is a reference node, the node literal is represented with
the original definition while the to-string method will produce the
corresponding character if it knowm.
Node information
With a xsm node, the operation are a limited number of node information
operations. The get-name method returns the first name found in a node.
If the node is a normal tag, the get-name will return the tag name. For
the other node, the method will return the first available string. This
also means, that the method will behave correctly with end tag node.
# create a tag node
const ntag (afnix:xml:XsmNode afnix:xml:XsmNode:TAG "afnix">
# get the tag name
ntag:get-name
There is a predicate for all types. For example, the text-p predicate
returns true if the node is a text node. The tag-p predicate returns
true if the node is a normal or reserved tag.
Document reading
A document is read in a way similar to the XmlDocument with the help of
the XsmDocument object. Once created, the document holds a vector of
nodes.
The document object
The XsmDocument object is a special xsm object designed to ease the
reading process of a document. The process of creating a document
consists of creating a document object, then binding a xsm reader,
parsing the input stream and storing the nodes in a vector. When the
operation is completed, the vector can be accessed by index.
# create a xms document
const xdoc (afnix:xml:XsmDocument "example.htm")
# get the document length
xdoc:length
Node information object
The XsoInfo object is a node information object designed to hold a node
name, an attributes list and eventually a text associated with the
node. For example, if a html document contains a anchor node, the
associated information node, will have the anchoring text stored as the
node information text.
# create a xso node by name and text
const info (afnix:xml:XsoInfo "a" "click here")
Simple model operations
The XsmDocument is designed to perform simple operations such like
searching all nodes that matches a particular name. While this
operation can be done easily, it is done in such a way that a vector of
node information is returned instead of a vector of nodes which can
always be constructed with a simple loop.
# create a xsm document
const xdoc (afnix:xml:XsmDocument "example.htm")
# get all node named "a" - forcing lower case
xdoc:get-info-vector "a" true
STANDARD XML REFERENCE
This appendix is a reference of the AFNIX standard xml module.
Symbol Description
afnix-xml module
afnix:xml nameset
XmlNode
The XmlNode class is the base class used to represent the xml tree. The
tree is built as a vector of nodes. Each node owns as well its parent
node. Walking in the tree is achieved by taking the child node and then
moving to the child and/or next node. The node also manages an empty
flags. It the empty flag is set, it is an error to add child nodes.
Predicate
node-p
Inheritance
Object
Methods
to-text -> String (none)
The to-text method returns a text representation of the tree
content. Unlike the write method, the tag are not generated, but
rather the text content is accumulated. This method is useful
tor read the node content. If a node does n;ot have text, the
nil string is returned.
write -> none (none|Stream|Buffer)
The write method write the node contents as well as the child
nodes to an output stream argument or a buffer. When node is
written, the method attempts to use the stream encoding in such
way that the contents fits into the requested output encoding.
Without argument, the node is written to the interpreter output
stream. with one argument, the node is written to the specified
stream or buffer.
name-p -> Boolean (String)
The name-p predicate checks if the name matches the node name.
Care should be taken that not all node have a name, and in such
case, the false value is returned. This method is useful when
the node is a tag.
attribute-p -> Boolean (String| String String)
The attribute-p predicate checks if there is a node attribute
that matches the string argument name. In the first form, the
predicate returns true is an attribute exists with the name
argument. In the second form, the predicate returns true if the
attribute name and value matches the arguments. The first
argument is the attribute name. The second argument is the
attribute value. Not all nodes have attributes. In such case,
the predicate always returns false.
parse -> none (String)
The parse method parses the string argument and adds the results
as a set of child node to the calling node. If the node is an
empty node, the method will almost fail. This method should be
used when an attempt is made to add some text that may contain
some xml tags.
get-parent -> XmlNode (none)
The get-parent method returns the parent node. If the node is
the root node, nil is returned.
set-parent -> none (XmlNode)
The set-parent method sets the parent node.
copy -> XmlNode (none)
The copy method copy the node tree by regenerating a new tree.
clear-child -> none (none)
The clear-child method clear the child node list, leaving the
node without child node.
add-child -> none (XmlNode|XmlNode Integer)
The add-child method adds a node argument as a child node to the
calling node. In the first form, the node is added at the end of
the node list. In the second form, the node is added by index
and all subsequent nodes are shifted by one position.
get-child -> XmlNode (Integer String)
The get-child method returns a child node by index or by name.
If the calling argument is an integer, the node is returned by
index. If the calling argument is a string, the node is returned
by name. If the node cannot be found, nil is returned raised.
get-index -> Integer (XmlNode)
The gett-index method returns a child node index. The node
argument is the node to find as a child node. If the node is not
found, an exception is raised.
merge -> none (XmlNode Integer)
The merge method merge an existing node with another one. The
first argument is the source node used for merging. The second
argument the child node index to merge. The method operates by
rst removing the child node at the specified index and then add
in position, the child nodes of the source node.
nil-child-p -> Boolean (none)
The nil-child-p predicate returns true if the node does not have
a child node.
lookup-child -> XmlNode (String)
The lookup-child method returns a child node by name. Unlike the
get-child method, the method raises an exception if the node
cannot be found.
child-length -> Integer (none)
The child-length method returns the number of children nodes.
get-source-line -> Integer (none)
The get-source-line method returns the node source line number
if any.
set-source-line -> none (Integer)
The set-source-line method sets the node source line number.
get-source-name -> String (none)
The get-source-name method returns the node source name if any.
set-source-name -> none (String)
The set-source-name method sets the node source name.
XmlTag
The XmlTag class is the base class used to represent a xml tag. A tag
is defined with a name and an attribute list. The tag is derived from
the xml node class and is not marked empty by default.
Predicate
tag-p
Inheritance
XmlNode
Constructors
XmlTag (String)
The XmlTag constructor creates a tag node. The node is not
marked empty.
XmlTag (String Boolean)
The XmlTag constructor creates a tag node. The first argument is
the tag name. The second argument is the empty flag.
Methods
set-name -> none (String)
The set-name method sets the tag name.
get-name -> String (none)
The get-name method returns the tag name.
clear-attribute -> none (node)
The clear-attribute method clear the node attribute list.
add-attribute -> none (Property)
The add-attribute method adds a new attribute to the tag. The
attribute must be new for this method to succeed. In doubt, the
set-attribute is preferable.
set-attribute -> none (String Literal)
The set-attribute method sets an attribute to the tag. The first
argument is the attribute name. The second argument is the
attribute value. If the attribute already exists, the old value
is replaced with the new one.
get-attribute -> Property (Integer|String)
The get-attribute method returns a tag attribute in the form o a
property object. With an integer object, the attribute is
returned by index. With a string object, the property is return
by name. If the property is not found, nil is returned.
get-attribute-value -> String (String)
The get-attribute-value method returns a tag attribute value by
name. The string argument is the attribute name. If the property
is not found, an exception is raised.
lookup-attribute -> Property (String)
The lookup-attribute method returns a tag attribute by name in
the form of a property. The string argument is the attribute
name. If the property is not found, an exception is raised.
attribut-length -> Integer (none)
The attribute-length method returns the number of attributes.
XmlText
The XmlText class is the xml text node. A text node is directly built
by the xml reader and the content placed into a string. By definition,
a text node is an empty node.
Predicate
text-p
Inheritance
XmlNode
Constructors
XmlText (none)
The XmlText constructor creates a default text node. By
definition, a text node is an empty node.
XmlText (String)
The XmlText constructor creates a text node with the string
argument.
Methods
set-xval -> none (String)
The set-xval method sets the text node value.
get-xval -> String (none)
The get-xval method returns the text node value.
to-normal -> String (none)
The to-normal method returns the normalized text node value.
XmlData
The XmlData class is the xml cdata node. A data node differs from the
text node in the sense that the data node contains characters that
could be reserved characters such like markup delimiters. The data node
is most of the time used to hold text used for scripting. The data node
is an empty node.
Predicate
data-p
Inheritance
XmlNode
Constructors
XmlData (none)
The XmlData constructor creates a default data node. By
definition, a data node is an empty node.
XmlData (String)
The XmlData constructor creates a data node with the string
argument.
Methods
set-xval -> none (String)
The set-xval method sets the data node value.
get-xval -> String (none)
The get-xval method returns the data node value.
XmlComment
The XmlComment class is the xml comment node. The comment node is a
special node that holds the comment text. The comment node is an empty
node.
Predicate
comment-p
Inheritance
XmlNode
Constructors
XmlComment (none)
The XmlComment constructor creates a default comment node. By
definition, a comment node is an empty node.
XmlComment (String)
The XmlComment constructor creates a comment node with the
string argument.
Methods
set-xval -> none (String)
The set-xval method sets the comment node value.
get-xval -> String (none)
The get-xval method returns the comment node value.
XmlDoctype
The XmlDoctype class is the xml document type node. In its simplest
form, the document type has just a name which acts the starting tag for
the document. The document type can also be associated with a system or
a public identifier. Note also that a local root node can be attached
to this node.
Predicate
doctype-p
Inheritance
XmlNode
Constructors
XmlDoctype (String)
The XmlDoctype constructor creates a document type with a
starting tag name as the string argument. This is the simplest
form of a document type definition.
XmlDoctype (String String)
The XmlDoctype constructor creates a document type with a
starting tag name and a system identifier. The first string
argument is the tag name. The second argument is the system
identifier.
XmlDoctype (String String String)
The XmlDoctype constructor creates a document type with a
starting tag name, a public and a system identifier. The first
string argument is the tag name. The second argument is the
public identifier. The third argument is the system identifier.
Methods
get-xval -> String (none)
The get-xval method returns the document type starting tag name.
get-public-id -> String (none)
The get-public-id method returns the document type public
identifier.
get-system-id -> String (none)
The get-system-id method returns the document type system
identifier.
XmlPi
The XmlPi class is the xml processing node. The processing node is a
tag node. Although a processing node is seen as tag with attributes,
the specification describes the processing node as a special tag with a
string value. The processing node is an empty node.
Predicate
pi-p
Inheritance
XmlNode
Constructors
XmlPi (String)
The XmlPi constructor creates a processing node with the name
string argument.
XmlPi (String String)
The XmlPi constructor creates a processing node with the name
string argument and the string value. The first argument is the
tag name. The second argument is the processing node value.
Methods
set-name -> none (String)
The set-name method sets the xml pi node name.
get-name -> String (none)
The get-name method returns the pi node name.
set-xval -> none (String)
The set-xval method sets the processing node value.
get-xval -> String (none)
The get-xval method returns the processing node value.
XmlDecl
The XmlDecl class is the xml declaration node. The declaration node is
a processing node. A declaration node is defined with a version id, an
encoding string and a standalone flag. Each value is represented by an
attribute at the tag level.
Predicate
decl-p
Inheritance
XmlPi
Constructors
XmlDecl (none)
The XmlDecl constructor creates a default declaration node. By
default, the declaration node is set with the xml version 1.0,
the UTF-8 encoding and the standalone flag is not set.
XmlDecl (String)
The XmlDecl constructor creates a declaration node with a
version. The string argument is the xml version version which
must be a supported one.
XmlDecl (String String)
The XmlDecl constructor creates a declaration node with a
version and an encoding. The string argument is the xml version
version which must be a supported one. The second argument is
the xml encoding.
XmlDecl (String String String)
The XmlDecl constructor creates a declaration node with a
version, an encoding and a standalone flag. The string argument
is the xml version version which must be a supported one. The
second argument is the xml encoding. The third argument is the
standalone flag.
XmlRef
The XmlRef class is the xml reference node class. This class is a base
class which cannot be instantiated directly. The class is designed to
hold reference, the only element which is in common is the string
representation.
Predicate
ref-p
Inheritance
XmlNode
Methods
set-xref -> none (String)
The set-xref method sets the node reference name.
get-xref -> String (none)
The get-xref method returns the node reference name.
XmlCref
The XmlCref class is the xml character reference node class. Normally
this class should only be used when building a xml tree manually.
During a parsing process, the character reference is automatically
expanded.
Predicate
cref-p
Inheritance
XmlRef
Constructors
XmlCref (none)
The XmlCref constructor creates a default character reference
those value is the null character.
XmlCref (Character|Integer)
The XmlCref constructor creates a character reference those
value is the character or integer argument.
Methods
set-value -> none (Character|Integer)
The set-value method sets the character reference value by
character or integer.
get-value -> Character (none)
The get-value method returns the character reference value.
XmlEref
The XmlEref class is the xml entity reference node class. The entity
reference is defined with a reference name.
Predicate
eref-p
Inheritance
XmlRef
Constructors
XmlEref (none)
The XmlCref constructor creates an empty entity reference.
XmlCref (String)
The XmlEref constructor creates an entity reference those value
is the string argument.
XmlSection
The XmlSection class is the xml section type node. A section node is
used to model conditional section that are part of a dtd. The section
value is a string that is evaluated by the xml processor. Most of the
time, it is a parameter entity reference which corresponds to the
keyword INCLUDE or IGNORE , but it could be anything else. A node is
also attached to this section.
Predicate
section-p
Inheritance
xmlNode
Constructors
XmlSection (String)
The XmlSection constructor creates a xml section node by value.
Methods
get-xval -> String (none)
The get-xval method returns the section node value.
XmlAttlist
The XmlAttlist class is the xml attribute list node class. A xml
attribute list is primarily defined with two names. The first name is
the element and the second name is the attribute name. There are 3
types of attribute list. The string type, the token type and the
enumeration type. The class manages each type by associating a type
descriptor which is detected at construction.
Predicate
attlist-p
Inheritance
XmlNode
Constructors
XmlAttlist (String String)
The XmlAttlist constructor creates an attribute list by element
name and attribute name. The first argument is the element name.
The second argument is the attribute name.
Methods
set-element-name -> none (String)
The set-element-name method sets the attribute list element
name.
get-element-name -> String (none)
The get-element-name method returns the attribute list element
name.
set-attribute-name -> none (String)
The set-attribute-name method sets the attribute list name.
get-attribute-name -> String (none)
The get-attribute-name method returns the attribute list name.
set-type -> none (String | Vector Boolean)
The set-type method set the attribute type by string or
enumeration vector. In its first form, the attribute type is
defined by a string. The type can be either, "CDATA", "ID",
"IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN" or
"NMTOKENS". In the second form, the attribute type is an
enumeration those values are defined in the argument vector. The
boolean argument controls the notation flag for that
enumeration.
set-default -> none (String)
The set-default method set the attribute value by string. The
string can be any value or the special value "#IMPLIED" and
"#REQUIRED". If the default value is fixed, the set-fixed is the
preferred method.
set-fixed -> none (String)
The set-fixed method set the fixed attribute default value by
string.
XmlRoot
The XmlRoot class is the top level root instantiated by the xml reader
when starting to parse a stream. There should be only one root node in
a tree. The root node does not have a parent node.
Predicate
root-p
Inheritance
XmlNode
Constructors
XmlRoot (none)
The XmlRoot constructor creates a default xml root node which is
empty.
Methods
get-declaration -> XmlDecl (none)
The get-declaration method returns the declaration node
associated with the root node. Normally, the declaration node is
the first child node.
del-declaration -> none (none)
The del-declaration method removes the declaration node
associated with the root node. Normally, the declaration node is
the first child node.
XmlDocument
The XmlDocument class is the xml document class. The document class is
the root document class that maintains a xml document along with its
associated tree and other useful information. Generally the class is
constructed with a file name or a name and an input stream that is used
for parsing the input data. The document can also be designed by
constructing manually the document tree. In that case, the document
name must be set explicitly.
Predicate
document-p
Inheritance
Nameable
Constructors
XmlDocument (none)
The XmlDocument constructor creates a default xml document.
XmlDocument (String)
The XmlDocument constructor creates a xml document by parsing
the file. The file name is the string argument.
XmlDocument (String Input)
The XmlDocument constructor creates a xml document by name and
by parsing the input stream. The first argument is the xml
document name. The second argument is the input stream to parse.
XmlDocument (String XmlRoot)
The XmlDocument constructor creates a xml document by name and
root node. The first argument is the xml document name. The
second argument is the xml root node.
Methods
set-name -> none (String)
The set-name method sets the xml document name. The get-name
method is available from the nameable base class.
get-root -> none (XmlRoot)
The get-root method returns the document xml root node.
XmlElement
The XmlElement class is the xml element class node. A xml element is
represented with a name and a value. It is during the processing phase
that the element value is interpreted. An element is built with a name
and a value.
Predicate
element-p
Inheritance
XmlNode
Constructors
XmlElement (String String)
The XmlElement constructor creates a xml element by name and
value. The first argument is the element name. The second
argument is the argument value.
Methods
set-name -> none (String)
The set-name method sets the xml element name.
get-name -> String (none)
The get-name method returns the element name.
set-xval -> none (String)
The set-xval method sets the xml element value.
get-xval -> String (none)
The get-xval method returns the element value.
XmlEntity
The XmlEntity class is the base class for the xml entity
representation. A xml entity can be either a general entity or a
parameter entity. They differ initially with the presence of the ’%’
character. Both entity model have a name which is path of the base
class.
Predicate
entity-p
Inheritance
XmlNode
Methods
set-name -> none (String)
The set-name method sets the entity name.
get-name -> String (none)
The get-name method returns the entity name.
XmlGe
The XmlGe class is the xml general entity node. In its simplest form,
the general entity has a name and a value. The entity type can also be
associated with a system or a public identifier with or without an
extra type name.
Predicate
ge-p
Inheritance
XmlEntity
Constructors
XmlGe (String String)
The XmlGe constructor creates a xml entity by name and value.
The first argument is the entity name. The second argument is
the entity value. Most of the time, the entity value is a
parameter entity.
XmlGe (String String String)
The XmlGe constructor creates a xml entity by name and
identifier. The first argument is the entity name. The second
argument is the entity public identifier. The third argument is
the entity system identifier.
XmlGe (String String String String)
The XmlGe constructor creates a xml entity by name, identifier
and data type. The first argument is the entity name. The second
argument is the entity public identifier. the third argument is
the entity system identifier. The fourth argument is the entity
type name.
Methods
get-xval -> String (none)
The get-xval method returns the entity value.
get-data -> String (none)
The get-data method returns the entity data type.
get-public-id -> String (none)
The get-public-id method returns the entity public identifier.
get-system-id -> String (none)
The get-system-id method returns the entity system identifier.
XmlPe
The XmlPe class is the xml parameter entity node. In its simplest form,
the parameter entity has a name and a value. The entity type can also
be associated with a system or a public identifier.
Predicate
ge-p
Inheritance
XmlEntity
Constructors
XmlPe (String String)
The XmlGe constructor creates a xml entity by name and value.
The first argument is the entity name. The second argument is
the entity value.
XmlPe (String String String)
The XmlGe constructor creates a xml entity by name and
identifier. The first argument is the entity name. The second
argument is the entity public identifier. The third argument is
the entity system identifier.
Methods
get-xval -> String (none)
The get-xval method returns the entity value.
get-public-id -> String (none)
The get-public-id method returns the entity public identifier.
get-system-id -> String (none)
The get-system-id method returns the entity system identifier.
XmlReader
The XmlReader class is the xml parser that operates on an input stream.
The reader creates a tree of nodes by reading the input stream and
returns the root node when an end-of-stream is reached. Multiple read
can be done sequentially. If the reset method is not called between
multiple read passes, the reader will accumulate the nodes in the
current tree.
Predicate
reader-p
Inheritance
Object
Constructors
XmlReader (none)
The XmlReader constructor creates a default xml reader.
Methods
reset -> none (none)
The reset method resets the xml reader. In particular, the root
node is restored to the nil node.
parse -> none (Input|String)
The parse method parses an input stream or a file. During the
parsing process, the root node is filled with the parsed nodes.
get-root -> XmlRoot (none)
The get-root method returns the parsed root node.
get-node -> XmlNode (String)
The get-node method parse a string and returns a node.
STANDARD XNE REFERENCE
Xne
The Xne is a nameset that binds constants used by the xne system.
Constants
ID
The ID constant defines a node access by id.
NAME
The NAME constant defines a node access by name.
INDEX
The INDEX constant defines a node access by child index. The
child index is node index seen from the parent.
XneTree
The XneTree is the xne node tree manipulation class. The class operates
with a node and provides numerous methods to manipulate the tree as
well as changing it. Before a tree is manipulated, it is recommended to
make a copy of such tree with the help of the node copy method.
Predicate
xne-tree-p
Inheritance
Object
Constructors
XmlTree (none)
The XmlTree constructor creates a default tree without a node.
XmlTree (XmlNode)
The XmlTree constructor creates a tree with a xml node. The node
stored in the object is the root of the tree subject to the
operations.
Methods
depth -> Integer (none)
The depth method returns the depth of the tree.
generate-id -> Integer (none)
The generate-id method generate a unique id for all node in the
tree. The id attribute is set by this method.
set-node -> none (XmlNode)
The set-node method sets the root tree node.
get-node -> XmlNode (none)
The get-node method returns the root tree node.
set-attribute -> none (none|String)
The set-attribute method sets an attribute to the whole tree. In
the first form, the attribute is set to the whole tree. In the
second form with a string argument, the attribute is set only on
the tag node those name matches the name argument.
clear-attribute -> none (none|String)
The clear-attribute method clear all attributes of the nodes in
the tree. In the first form, the node attributes are cleared for
all nodes in the tree. In the second form with a string
argument, the attributes are cleared only with the tag node
those name matches the name argument.
set-prefix -> none (String)
The set-prefix method sets a prefix on all nodes in the tree.
clear-prefix -> none (none)
The clear-prefix method clear the prefix for all nodes in the
tree.
select -> Vector (XneCond {Boolean])
The select method selects the node in the tree taht matches the
condition argument. In the first form, with one argument, the
whole tree is searched. In the seaond form, with a boolean
argument, the whole tree is searched if the second argument is
false. If the boolean argument is true, the method call behaves
like a call with the condition only.
XneChild
The XneCond is the xne condition class. The sole purpose of this class
is to define one or several condition that a node must satisfy in order
to be selected. The condition are accumulated in a list and later
checked for a particular node. Note that an empty condition always
succeds.
Predicate
xne-cond-p
Inheritance
Object
Constructors
XneCond (none)
The XneCond constructor creates a default condition. The default
condition is empty. The empty condition always succeds.
Methods
add -> none (Xne [String|Integer])
The add adds a condition by type. The first argument is the
conditiontype. The second argument is a condition information
such like a string or an integer.
valid-p -> Boolean (XmlNode)
The valid-p predicate checks that a node matches a condition. If
the condition succeeds, the predicate returns true.