Man Linux: Main Page and Category List

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.