Provided by: afnix_2.8.1-2_amd64 bug

NAME

       xml - standard xml module

STANDARD XML MODULE

       The  Standard  XMLmodule  is  an  original  implementation of the XML markup language. The
       module  provides  the  necessary  objects  for  parsing  a  xml  description  as  well  as
       manipulating  the parsed tree. The module can be extended to a service as a mean to act as
       a XML processor. The module also provides the support for a simple modelwhich  enable  the
       quick parsing of documents with a relaxed rule checking approach.

       XML tree representation
       A  xml  document  is represented with a tree. At the top of the tree is the XmlRootobject.
       The root object is not part of the document, but acts as the primary container  for  other
       objects.  A  xml  document  starts  with  a  root  node  and  all other child elements are
       XmlNodeobjects.

       Node base object
       The xml tree is built with the XmlNodeobject. The node  object  has  different  derivation
       depending  on  the required representation. For example, the XmlRootobject is derived from
       the XmlNodeobject. 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-pthat can be used to assert  the
       node type.

       # check a node
       assert true (afnix:xml:node-p node)

       The  add-childmethod  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 parsemethod 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 XmlTextnode with the  value  The  quick
       brown  .  The  second  node is a XmlTagnode with name b. Finally, the third node is also a
       XmlTextnode with the value jumps over the lazy dog. It should be noted that the  tag  node
       has a child XmlTextnode with the value fox. This example also illustrates the power of the
       parsemethod 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 referencewith the
       parsemethod. 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 XmlCrefis provided in the module.

       Tag object
       The XmlTagclass 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-attributemethod
       operates with a Propertyobject while the set-attributeoperates 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  XmlTextnode
       which  is  designed  to  hold  some text without markup. It is this kind of nodes which is
       automatically instantiated by the parsemethod, as described earlier. The other  object  is
       the  XmlDatawhich  corresponds to the xml CDATAspecial markup. With a character data node,
       the characters are not interpreted, including those that indicate markup starts  like  <or
       end like >. The XmlDatais particularly used to store scripts or other program textinside 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 XmlDocumentobject 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.

       Node tree operations
       The class XneTreeprovides a single framework to operate on a node and its associated tree.
       Since a node always carries a sub-tree, the node treeterm will be used to reference it.

       Creating a node tree
       A  node  tree  is  created either from a node at construction or with the help of the set-
       nodemethod.

       # 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
       depthmethod  returns  the depth of the node tree. The get-nodemethods returns the the node
       associated with the tree.

       # get the tree depth
       println (tree:depth)

       Namespace operations
       The concept of namespaceis 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 nameis composed of a prefixand 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-prefixchanges  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-
       attributemethod of the XmlTagis the definitive answer.

       # clear all attributes
       tree:clear-attribute
       # clear all attributes by tag name
       tree:clear-attribute "p"

       The set-attributemethod 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-
       attributemethod 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-idgenerates 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 XmlTagnode,  although
       it might not be always the case.

       Node selection
       The process of finding a child node is obtained with the help of the XneCondclass combined
       with the selectmethod of the XneTreeObject. The selectmethod 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 first 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 works for all nodes. This previous example will return  all  nodes  in
       the tree.

       Node condition
       The  XmlCondclass provides several method to add a conditions. The addmethod 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 selectmethod with this condition, all nodes in the tree  that  have  the  tag  name
       pwill 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 selectmethod with this condition, all nodes in the tree that  have  the
       tag name pand those child index is 0 will be selected.

       Selection result
       The  node  selection  operates by default on the whole tree. The selectmethod, when called
       with a second boolean argument can restrict 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.

       Simple model node
       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.  Note  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 generally in poorly written html document.
       In the simple model, a XsmNodeis 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-stringand  to-literalmethods  are
       available.  When  the to-literalmethod 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-stringmethod will produce the corresponding character if it known.

       Node information
       With  a  xsm  node,  the operation are a limited number of node informationoperations. The
       get-namemethod returns the first name found in a node. If the node is a  normal  tag,  the
       get-namewill  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-ppredicate returns true if the
       node is a text node. The tag-ppredicate returns true if the node is a normal  or  reserved
       tag.

       Document reading
       A   document   is  read  in  a  way  similar  to  the  XmlDocumentwith  the  help  of  the
       XsmDocumentobject. Once created, the document holds a vector of nodes.

       The document object
       The XsmDocumentobject 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 XsoInfoobject 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 XsmDocumentis 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 informationis 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

       XmlNode
       The  XmlNodeclass 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-textmethod 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  not
              have text, the nil string is returned.

              write -> none (none|OutputStream|Buffer)
              The  writemethod  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-ppredicate 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-ppredicate  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 parsemethod 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-parentmethod returns the parent node. If the node is the root node, nil is
              returned.

              set-parent -> none (XmlNode)
              The set-parentmethod sets the parent node.

              copy -> XmlNode (none)
              The copymethod copy the node tree by regenerating a new tree.

              del-child -> none (Integer | String | String String | String String String)
              The del-childmethod deletes one or several child nodes.  In  the  first  form,  the
              children  is  deleted  either  by index or by name. When a string argument is used,
              several node might be removed.  In  the  second  form,  the  child  node  name  and
              attribute  name  must be matched. In the third form, the child node name, attribute
              name and value must be matched.

              del-attribute-child -> none (String | String String)
              The del-attribute-childmethod deletes one or several  child  nodes.  In  the  first
              form,  the children are deleted by attribute name. In the second form, the children
              are delete by attribute name and value.

              clear-child -> none (none)
              The clear-childmethod clear the child node list, leaving  the  node  without  child
              node.

              add-child -> none (XmlNode|XmlNode Integer)
              The  add-childmethod  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-childmethod  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-indexmethod 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  mergemethod 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  first 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-ppredicate returns true if the node does not have a child node.

              child-p -> Boolean (String | String String | String String String)
              The child-ppredicate returns true if  the  node  has  a  child  with  a  node  name
              argument.  In  the  first  form, the name is to be matched by the predicate. In the
              second form, the node nae and the attribute name must  be  matched.  In  the  third
              form, the node name, attribute name and value must be matched.

              attribute-child-p -> Boolean (String String | String String String)
              The  attribute-child-ppredicate  returns  true  if  the  node  has  a child with an
              attribute name argument. In the first form, the attribute name must be matched.  In
              the second form, the attribute name and value must be matched.

              lookup-child -> XmlNode (String)
              The  lookup-childmethod  returns  a child node by name. Unlike the get-childmethod,
              the method raises an exception if the node cannot be found.

              child-length -> Integer (none|String)
              The child-lengthmethod returns the number of children nodes.  In  the  first  form,
              without  argument,  the  total  number of children nodes is returned. In the second
              form, the total number of nodes that match the tag argument name is returned.

              get-source-line -> Integer (none)
              The get-source-linemethod returns the node source line number if any.

              set-source-line -> none (Integer)
              The set-source-linemethod sets the node source line number.

              get-source-name -> String (none)
              The get-source-namemethod returns the node source name if any.

              set-source-name -> none (String)
              The set-source-namemethod sets the node source name.

       XmlTag
       The XmlTagclass 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 XmlTagconstructor creates a tag node. The node is not marked empty.

              XmlTag (String Boolean)
              The XmlTagconstructor 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-namemethod sets the tag name.

              get-name -> String (none)
              The get-namemethod returns the tag name.

              clear-attribute -> none (node)
              The clear-attributemethod clear the node attribute list.

              add-attribute -> none (Property)
              The  add-attributemethod adds a new attribute to the tag. The attribute must be new
              for this method to succeed. In doubt, the set-attributeis preferable.

              set-attribute -> none (String Literal)
              The set-attributemethod 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-attributemethod 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-valuemethod 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-attributemethod 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.

              attribute-length -> Integer (none)
              The attribute-lengthmethod returns the number of attributes.

       XmlText
       The XmlTextclass 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  XmlTextconstructor  creates a default text node. By definition, a text node is
              an empty node.

              XmlText (String)
              The XmlTextconstructor creates a text node with the string argument.

       Methods

              set-xval -> none (String)
              The set-xvalmethod sets the text node value.

              get-xval -> String (none)
              The get-xvalmethod returns the text node value.

              to-normal -> String (none)
              The to-normalmethod returns the normalized text node value.

       XmlData
       The XmlDataclass 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  XmlDataconstructor  creates a default data node. By definition, a data node is
              an empty node.

              XmlData (String)
              The XmlDataconstructor creates a data node with the string argument.

       Methods

              set-xval -> none (String)
              The set-xvalmethod sets the data node value.

              get-xval -> String (none)
              The get-xvalmethod returns the data node value.

       XmlComment
       The XmlCommentclass 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  XmlCommentconstructor creates a default comment node. By definition, a comment
              node is an empty node.

              XmlComment (String)
              The XmlCommentconstructor creates a comment node with the string argument.

       Methods

              set-xval -> none (String)
              The set-xvalmethod sets the comment node value.

              get-xval -> String (none)
              The get-xvalmethod returns the comment node value.

       XmlDoctype
       The XmlDoctypeclass 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  XmlDoctypeconstructor  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 XmlDoctypeconstructor 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 XmlDoctypeconstructor 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-xvalmethod returns the document type starting tag name.

              get-public-id -> String (none)
              The get-public-idmethod returns the document type public identifier.

              get-system-id -> String (none)
              The get-system-idmethod returns the document type system identifier.

       XmlPi
       The  XmlPiclass  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 XmlPiconstructor creates a processing node with the name string argument.

              XmlPi (String String)
              The  XmlPiconstructor  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-namemethod sets the xml pi node name.

              get-name -> String (none)
              The get-namemethod returns the pi node name.

              set-xval -> none (String)
              The set-xvalmethod sets the processing node value.

              get-xval -> String (none)
              The get-xvalmethod returns the processing node value.

              map-xval -> Plist (String)
              The map-xvalmethod map the processing node value to a property list.

       XmlDecl
       The XmlDeclclass 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  XmlDeclconstructor  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  XmlDeclconstructor  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 XmlDeclconstructor 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 XmlDeclconstructor 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  XmlRefclass  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-xrefmethod sets the node reference name.

              get-xref -> String (none)
              The get-xrefmethod returns the node reference name.

       XmlCref
       The  XmlCrefclass  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  XmlCrefconstructor  creates  a  default character reference those value is the
              null character.

              XmlCref (Character|Integer)
              The XmlCrefconstructor creates a character reference those value is  the  character
              or integer argument.

       Methods

              set-value -> none (Character|Integer)
              The set-valuemethod sets the character reference value by character or integer.

              get-value -> Character (none)
              The get-valuemethod returns the character reference value.

       XmlEref
       The  XmlErefclass  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 XmlCrefconstructor creates an empty entity reference.

              XmlCref (String)
              The XmlErefconstructor creates an  entity  reference  those  value  is  the  string
              argument.

       XmlSection
       The  XmlSectionclass  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 XmlSectionconstructor creates a xml section node by value.

       Methods

              get-xval -> String (none)
              The get-xvalmethod returns the section node value.

       XmlAttlist
       The  XmlAttlistclass  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  XmlAttlistconstructor  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-namemethod sets the attribute list element name.

              get-element-name -> String (none)
              The get-element-namemethod returns the attribute list element name.

              set-attribute-name -> none (String)
              The set-attribute-namemethod sets the attribute list name.

              get-attribute-name -> String (none)
              The get-attribute-namemethod returns the attribute list name.

              set-type -> none (String | Vector Boolean)
              The  set-typemethod  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-defaultmethod 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-fixedis the preferred method.

              set-fixed -> none (String)
              The set-fixedmethod set the fixed attribute default value by string.

       XmlRoot
       The XmlRootclass 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 XmlRootconstructor creates a default xml root node which is empty.

       Methods

              dup-body -> XmlBody (none)
              The dup-bodymethod duplicates the root node by duplicating the  root  body  without
              the declaration node.

              declaration-p -> Boolean (none)
              The  declaration-ppredicate  returns  true if a declaration node exists in the root
              node.

              get-declaration -> XmlDecl (none)
              The get-declarationmethod returns the declaration node  associated  with  the  root
              node.  Normally,  the  declaration node is the first child node. If the declaration
              node does not exist, an exception is raised.

              get-encoding -> String (none)
              The get-encodingmethod returns the root encoding mode. The root  encoding  mode  is
              extracted from the declaration node, if such node exists, or the default xml system
              encoding is returned.

       XmlDocument
       The XmlDocumentclass 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 XmlDocumentconstructor creates a default xml document.

              XmlDocument (String)
              The  XmlDocumentconstructor  creates  a  xml document by parsing the file. The file
              name is the string argument.

              XmlDocument (String InputStream)
              The XmlDocumentconstructor 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 XmlDocumentconstructor 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-namemethod sets the xml document name. The get-namemethod is available from
              the nameablebase class.

              get-root -> XmlRoot (none)
              The get-rootmethod returns the document xml root node.

              get-body -> XmlRoot (none)
              The get-bodymethod returns the document xml root node body without the  declaration
              node.

       XmlElement
       The  XmlElementclass  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  XmlElementconstructor  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-namemethod sets the xml element name.

              get-name -> String (none)
              The get-namemethod returns the element name.

              set-xval -> none (String)
              The set-xvalmethod sets the xml element value.

              get-xval -> String (none)
              The get-xvalmethod returns the element value.

       XmlEntity
       The XmlEntityclass 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-namemethod sets the entity name.

              get-name -> String (none)
              The get-namemethod returns the entity name.

       XmlGe
       The XmlGeclass 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 XmlGeconstructor 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 XmlGeconstructor 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 XmlGeconstructor 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-xvalmethod returns the entity value.

              get-data -> String (none)
              The get-datamethod returns the entity data type.

              get-public-id -> String (none)
              The get-public-idmethod returns the entity public identifier.

              get-system-id -> String (none)
              The get-system-idmethod returns the entity system identifier.

       XmlPe
       The  XmlPeclass  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  XmlGeconstructor 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 XmlGeconstructor 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-xvalmethod returns the entity value.

              get-public-id -> String (none)
              The get-public-idmethod returns the entity public identifier.

              get-system-id -> String (none)
              The get-system-idmethod returns the entity system identifier.

       XmlReader
       The XmlReaderclass 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 XmlReaderconstructor creates a default xml reader.

       Methods

              reset -> none (none)
              The resetmethod resets the xml reader. In particular, the root node is restored  to
              the nil node.

              parse -> none (InputStream|String)
              The  parsemethod  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-rootmethod returns the parsed root node.

              get-node -> XmlNode (String)
              The get-nodemethod parse a string and returns a node.

       Xne
       The Xneis a nameset that binds constants used by the xne system.

       Constants

              ID
              The IDconstant defines a node access by id.

              PI
              The PIconstant defines an access selector for a processing instruction node.

              GE
              The GEconstant defines an access selector for a general entity node.

              TAG
              The TAGconstant defines an access selector for a tag node.

              ENT
              The ENTconstant defines an access selector for an entity node.

              EREF
              The EREFconstant defines an access selector for an entity reference node.

              CREF
              The CREFconstant defines an access selector for an character reference node.

              ELEM
              The ELEMconstant defines an access selector for an element node.

              TEXT
              The TEXTconstant defines an access selector for a text node.

              NAME
              The NAMEconstant defines a node access by name.

              CDATA
              The CDATAconstant defines an access selector for a character data node.

              INDEX
              The INDEXconstant defines a node access by child index. The  child  index  is  node
              index seen from the parent.

       XneTree
       The  XneTreeis  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
       copymethod.

       Predicate

              xne-tree-p

       Inheritance

              Object

       Constructors

              XmlTree (none)
              The XmlTreeconstructor creates a default tree without a node.

              XmlTree (XmlNode)
              The XmlTreeconstructor 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 depthmethod returns the depth of the tree.

              generate-id -> Integer (none)
              The  generate-idmethod  generate  a  unique  id  for  all  node in the tree. The id
              attribute is set by this method.

              set-node -> none (XmlNode)
              The set-nodemethod sets the root tree node.

              get-node -> XmlNode (none)
              The get-nodemethod returns the root tree node.

              set-attribute -> none (none|String)
              The set-attributemethod 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-attributemethod 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-prefixmethod sets a prefix on all nodes in the tree.

              clear-prefix -> none (none)
              The clear-prefixmethod clear the prefix for all nodes in the tree.

              select -> Vector (XneCond [Boolean])
              The  selectmethod selects the node in the tree that matches the condition argument.
              In the first form, with one argument, the whole tree is  searched.  In  the  second
              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  XneCondis 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 succeeds.

       Predicate

              xne-cond-p

       Inheritance

              Object

       Constructors

              XneCond (none)
              The XneCondconstructor creates a default condition. The default condition is empty.
              The empty condition always succeeds.

       Methods

              add -> none (Xne [String|Integer])
              The  addadds  a  condition  by  type. The first argument is the condition type. The
              second argument is a condition information such like a string or an integer.

              valid-p -> Boolean (XmlNode)
              The valid-ppredicate checks that a node  matches  a  condition.  If  the  condition
              succeeds, the predicate returns true.

       XsmNode
       The  XsmNodeis  a base class which is part of the xml simple model (xsm). In this model, a
       xml (or sgml, or html) text is represented by a node which can be either a tag, a text  or
       a reference node. There is no concept of tree. The node content is stored in the form of a
       text string. This simple model is designed to parse weak  data  representation  such  like
       html  text  and  later process it at the user discretion. The default representation is an
       empty text node.

       Predicate

              xsm-node-p

       Inheritance

              Object

       Constants

              TXT
              The TXTconstant defines a xsm text node.

              TAG
              The TAGconstant defines a xsm tag node.

              REF
              The REFconstant defines a xsm reference node.

              END
              The ENDconstant defines a xsm end node.

       Constructors

              XsmNode (none)
              The XsmNodeconstructor creates a default xsm node which is an empty text node.

              XsmNode (String)
              The XsmNodeconstructor creates a xsm text node by value. The string argument is the
              text node value

              XsmNode (Item String)
              The  XsmNodeconstructor  creates  a  xsm  text  node  by  type and value. The first
              argument is the node type. The second argument is the node text value.

       Methods

              text-p -> Boolean (none)
              The text-ppredicate returns true if the node is a text node.

              tag-p -> Boolean (none)
              The tag-ppredicate returns true if the node is a tag node.

              ref-p -> Boolean (none)
              The reference-ppredicate returns true if the node is a reference node.

              end-p -> Boolean (none)
              The end-ppredicate returns true if the node is a reference node.

              normal-p -> Boolean (none)
              The normal-ppredicate returns true if the node is a normal tag node.

              reserved-p -> Boolean (none)
              The reserved-ppredicate returns true if the node is a reserved tag node.

              textable-p -> Boolean (none)
              The textable-ppredicate returns true if the node is a textable node, that is a text
              node or a reference node.

              get-source-line -> Integer (none)
              The get-source-linemethod returns the node source line number if any.

              set-source-line -> none (Integer)
              The set-source-linemethod sets the node source line number.

              get-source-name -> String (none)
              The get-source-namemethod returns the node source name if any.

              set-source-name -> none (String)
              The set-source-namemethod sets the node source name.

              get-name -> String (none)
              The get-namemethod returns the next available name. name.

       XsmReader
       The  XmlReaderclass  is  the  simple  model  node  reader.  The  reader  operates with the
       parsemethod and returns a node or nil if the end of stream  is  reached.  Unlike  the  xml
       reader, this reader does not build a tree and the node content is not even parsed. In this
       model, the node content is to be interpreted at the user discretion.

       Predicate

              xsm-reader-p

       Inheritance

              Object

       Constructors

              XsmReader (none)
              The XsmReaderconstructor creates a default xsm reader. The reader is not  bound  to
              any stream.

              XsmReader (InputStream)
              The XsmReaderconstructor creates a xsm reader with an input stream. The argument is
              the input bound to the reader.

              XsmReader (String)
              The XsmReaderconstructor creates a xsm reader with  an  input  string  stream.  The
              argument  is  a  string which is used to create an input string stream bound to the
              reader.

       Methods

              set-input-stream -> none (InputStream)
              The set-input-streammethod bind a new input stream to the reader.  Subsequent  read
              will use the newly bound stream

              get-node -> XsmNode (none)
              The get-nodemethod parses the input stream and returns the available node.

       XsmDocument
       The  XsmDocumentclass  is  the document class that maintains a xsm document along with its
       associated list of nodes 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.
       When the input stream has been parsed, the nodes are stored  in  a  vector  which  can  be
       access by index.

       Predicate

              document-p

       Inheritance

              Nameable

       Constructors

              XsmDocument (none)
              The XsmDocumentconstructor creates a default xsm document.

              XsmDocument (String)
              The  XsmDocumentconstructor  creates a xsm document by name. The string argument is
              the file name to parse.

              XsmDocument (String InputStream)
              The XsmDocumentconstructor creates a xsm document by name and by parsing the  input
              stream.  The  first  argument  is the xsm document name. The second argument is the
              input stream to parse.

       Methods

              set-name -> none (String)
              The set-namemethod sets the xsm document name. The get-namemethod is available from
              the nameablebase class.

              length -> Integer (none)
              The lengthmethod returns the xsm document length. The document length is the number
              of nodes parsed and stored in the document.

              get-node -> XsmNode (Integer)
              The get-nodemethod returns a document node by index.

              get-info -> XsoInfo (Integer [Boolean])
              The get-infomethod returns a  node  info  object  by  index.  The  info  object  is
              evaluated  dynamically  from the document node. In the first form, the node name is
              used to find the node end tag in order to construct the info  text  value.  In  the
              second form, the boolean argument, if true, forces the node name to be converted to
              lower case prior any comparison.

              get-info-vector -> XsoInfo (String [Boolean])
              The get-info-vetcormethod returns an info object vector by name. Each  info  object
              have  their  name  that  matches  the string argument. The info object is evaluated
              dynamically from the document node. In the first form, the node  name  is  used  to
              match a tag node and then find the node end tag in order to construct the info text
              value. In the second form, the boolean argument, if true, forces the node  name  to
              be converted to lower case prior any comparison.

       XsoInfo
       The  XsoInfoclass  is  a xml/xsm information node used to carry simple information about a
       tag. The node is constructed by name, with a set  of  attributes  and  eventually  a  text
       associated with the node. The text information is generally the one associated between the
       start tag and the end tag. In the case of complex tree, such text data might be empty.

       Predicate

              xso-info-p

       Inheritance

              Nameable

       Constructors

              XsoInfo (none)
              The XsoInfoconstructor creates a default info object.

              XsoInfo (String)
              The XsoInfoconstructor creates an info object by name. The string argument  is  the
              node info name.

              XsoInfo (String String)
              The  XsoInfoconstructor creates an info object by name and text. The first argument
              is the node info name. The second argument is the node text information.

       Methods

              set-name -> none (String)
              The set-namemethod sets the info object name.

              set-attribute -> none (String Literal)
              The set-attributemethod sets an attribute by name and value. The first argument  is
              the attribute name. The second argument is the attribute value.

              get-attribute-list -> Plist (none)
              The  get-attribute-listmethod  returns  the  node  attribute  list in the form of a
              property list object.

              get-attribute-value -> String (String)
              The get-attribute-valuemethod returns the  attribute  value  by  name.  The  string
              argument is the attribute name.

              set-text -> none (String)
              The set-textmethod sets the info object text.

              get-text -> String (none)
              The get-textmethod returns the text information.