xml - standard xml module

       xml - standard xml module

       The Standard XML module 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 model which enable the quick parsing of documents with a relaxed rule checking approach.

       XMLtreerepresentation
       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. A xml  document  starts
       with a root node and all other child elements are XmlNode objects.

       Nodebaseobject
       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.

       Tagobject
       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)

       Textobjects
       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.

       Documentreading
       A xml document is read by scanning an input stream an building a representation of the xml tree.

       Thedocumentobject
       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)

       Therootnodecontent
       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.

       Nodetreeoperations
       The class XneTree provides a single framework to operate on a node and its associated tree. Since a  node
       always carries a sub-tree, the node tree term will be used to reference it.

       Creatinganodetree
       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)

       Namespaceoperations
       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.

       Attributeoperations
       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

       Nodelocationandsearching
       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.

       Nodeselection
       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 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.

       Nodecondition
       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.

       Selectionresult
       The node selection operates by default on the whole tree. The select method, 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.

       Simplemodelnode
       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 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.

       Creatinganode
       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 --")

       Noderepresentation
       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 known.

       Nodeinformation
       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.

       Documentreading
       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.

       Thedocumentobject
       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

       Nodeinformationobject
       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")

       Simplemodeloperations
       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

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

       Methodsto-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 not have text, the nil string is returned.

              write->none(none|OutputStream|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|StringString)
              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.

              del-child->none(Integer|String|StringString|StringStringString)
              The  del-child  method  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|StringString)
              The del-attribute-child method 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-child method clear the child node list, leaving the node without child node.

              add-child->none(XmlNode|XmlNodeInteger)
              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(IntegerString)
              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(XmlNodeInteger)
              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  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-p predicate returns true if the node does not have a child node.

              child-p->Boolean(String|StringString|StringStringString)
              The child-p predicate 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(StringString|StringStringString)
              The  attribute-child-p  predicate  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-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|String)
              The child-length method 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-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

       ConstructorsXmlTag(String)
              The XmlTag constructor creates a tag node. The node is not marked empty.

              XmlTag(StringBoolean)
              The XmlTag constructor creates a tag node. The first argument is the tag name. The second argument
              is the empty flag.

       Methodsset-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(StringLiteral)
              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.

              attribute-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

       ConstructorsXmlText(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.

       Methodsset-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

       ConstructorsXmlData(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.

       Methodsset-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

       ConstructorsXmlComment(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.

       Methodsset-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

       ConstructorsXmlDoctype(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(StringString)
              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(StringStringString)
              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.

       Methodsget-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

       ConstructorsXmlPi(String)
              The XmlPi constructor creates a processing node with the name string argument.

              XmlPi(StringString)
              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.

       Methodsset-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.

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

       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

       ConstructorsXmlDecl(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(StringString)
              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(StringStringString)
              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

       Methodsset-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

       ConstructorsXmlCref(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.

       Methodsset-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

       ConstructorsXmlEref(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

       ConstructorsXmlSection(String)
              The XmlSection constructor creates a xml section node by value.

       Methodsget-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

       ConstructorsXmlAttlist(StringString)
              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.

       Methodsset-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|VectorBoolean)
              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

       ConstructorsXmlRoot(none)
              The XmlRoot constructor creates a default xml root node which is empty.

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

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

              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. If the declaration node does not exist, an exception
              is raised.

              get-encoding->String(none)
              The get-encoding method 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  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

       ConstructorsXmlDocument(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(StringInputStream)
              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(StringXmlRoot)
              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.

       Methodsset-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->XmlRoot(none)
              The get-root method returns the document xml root node.

              get-body->XmlRoot(none)
              The get-body method returns the document xml root node body without the declaration 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

       ConstructorsXmlElement(StringString)
              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.

       Methodsset-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

       Methodsset-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

       ConstructorsXmlGe(StringString)
              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(StringStringString)
              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(StringStringStringString)
              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.

       Methodsget-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

       ConstructorsXmlPe(StringString)
              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(StringStringString)
              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.

       Methodsget-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

       ConstructorsXmlReader(none)
              The XmlReader constructor creates a default xml reader.

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

              parse->none(InputStream|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.

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

       ConstantsID
              The ID constant defines a node access by id.

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

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

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

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

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

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

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

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

              NAME
              The NAME constant defines a node access by name.

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

              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

       ConstructorsXmlTree(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.

       Methodsdepth->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 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  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 succeeds.

       Predicate

              xne-cond-p

       Inheritance

              Object

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

       Methodsadd->none(Xne[String|Integer])
              The add adds 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-p predicate checks that a node matches a  condition.  If  the  condition  succeeds,  the
              predicate returns true.

       XsmNode
       The  XsmNode  is 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

       ConstantsTXT
              The TXT constant defines a xsm text node.

              TAG
              The TAG constant defines a xsm tag node.

              REF
              The REF constant defines a xsm reference node.

              END
              The END constant defines a xsm end node.

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

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

              XsmNode(ItemString)
              The  XsmNode constructor creates a xsm text node by type and value. The first argument is the node
              type. The second argument is the node text value.

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

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

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

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

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

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

              textable-p->Boolean(none)
              The textable-p predicate 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-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.

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

       XsmReader
       The  XmlReader  class  is  the  simple  model  node reader. The reader operates with the parse method 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

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

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

              XsmReader(String)
              The  XsmReader  constructor  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.

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

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

       XsmDocument
       The  XsmDocument class 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

       ConstructorsXsmDocument(none)
              The XsmDocument constructor creates a default xsm document.

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

              XsmDocument(StringInputStream)
              The XsmDocument constructor 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.

       Methodsset-name->none(String)
              The set-name method sets the xsm document name. The get-name method is available from the nameable
              base class.

              length->Integer(none)
              The  length  method  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-node method returns a document node by index.

              get-info->XsoInfo(Integer[Boolean])
              The get-info method 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-vetcor method 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 XsoInfo class 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

       ConstructorsXsoInfo(none)
              The XsoInfo constructor creates a default info object.

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

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

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

              set-attribute->none(StringLiteral)
              The set-attribute method 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-list  method  returns  the  node  attribute list in the form of a property list
              object.

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

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

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

AFNIX Module                                          AFNIX                                               xml(3)