Node (OpenText Process Suite Platform 10.8 Java SDK API)

java.lang.Object
- com.eibus.xml.nom.Node

public class Node
extends java.lang.Object

This class provides a number of static methods that can work on XML nodes that are represented by Java integers. Look at Document for more information.

 Most of methods of this class requires XML element/node references as inputs.
 If the node references are
 - non-zero invalid (positive) references, and 'bus.xml.nom.exceptions.enabled' property is enabled, then the method throws XMLException
 - zero and negative values, no effect

Note: Manipulation methods like createElement(),setAttributeNS and so will not check for either the validness or welformedness of the resultant xml.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`WRITE_HEADER` Use this constant when you want to include xml header while serialization in Node.writeToFile()
`static int`	`WRITE_NORMAL` Use this constant when you want to do normal serialization in Node.write()
`static int`	`WRITE_PRETTY` Use this constant when you want to do pretty serialization in Node.write()

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static int`	`add(int node, int dest)` Adds the specified node to the destination node.
`static int`	`add(int from, int to, int dest)` Adds a range of nodes to the destination node.
`static int`	`append(int node, int destination)` Appends the specified node to most right sibling of the destination node.
`static int`	`append(int from, int to, int dest)` Appends a range of nodes to most right sibling of the destination node.
`static int`	`appendToChildren(int node, int destination)` Appends the specified node to the children of the destination node.
`static int`	`appendToChildren(int from, int to, int dest)` Appends the range of nodes to the children of the destination node.
`static void`	`captureTaceInMap(int node)`
`static int`	`clone(int node, boolean deep)` Returns a clone of the node.
`static int`	`createCDataElement(java.lang.String tag, java.lang.String text, int parent)` Creates a new CDATA element by name 'tag' with 'text' as CData section, and appends it to 'parent'.
`static int`	`createCDataElementNS(java.lang.String name, java.lang.String CDataContent, int parent)` Deprecated. in C3, use createCDataElementWithParentNS()
`static int`	`createCDataElementNS(java.lang.String name, java.lang.String CDataContent, java.lang.String prefix, int parent)` Deprecated. in C3, use createCDataElementNSWithPrefix()
`static int`	`createCDataElementNS(java.lang.String name, java.lang.String CDataContent, java.lang.String prefix, java.lang.String namespaceURI, int parent)` Creates a new CDATA element with input namespace details and appends it to the children of the indicated parent.
`static int`	`createCDataElementNSWithPrefix(java.lang.String name, java.lang.String CDataContent, java.lang.String prefix, int parent)` Creates a new CDATA element with input 'prefix' and appends it to the children of the indicated parent.
`static int`	`createCDataElementWithParentNS(java.lang.String name, java.lang.String CDataContent, int parent)` Creates a new CDATA element with parent namespace details and appends it to the children of the indicated parent.
`static int`	`createElement(java.lang.String tag, int parent)` Creates a new element with the given tag and appends it to parent.
`static int`	`createElementNS(java.lang.String name, java.lang.String content, int parent)` Deprecated. in C3, use createElementWithParentNS()
`static int`	`createElementNS(java.lang.String name, java.lang.String content, java.lang.String prefix, int parent)` Deprecated. in C3, use createElementNSWithPrefix()
`static int`	`createElementNS(java.lang.String name, java.lang.String content, java.lang.String prefix, java.lang.String namespaceURI, int parent)` Creates a new element with the given namespace details and appends it to the children of the indicated parent.
`static int`	`createElementNSWithPrefix(java.lang.String name, java.lang.String content, java.lang.String prefix, int parent)` Creates a new element with namespace prefix 'prefix' and appends it to the children of the indicated parent.
`static int`	`createElementWithParentNS(java.lang.String name, java.lang.String content, int parent)` Creates a new element with parent namespace details and appends it to the children of the indicated parent.
`static int`	`createTextElement(java.lang.String tag, java.lang.String text, int parent)` Creates a new element, appends it to parent, and creates a new text node which is appended to the newly created element.
`static byte[]`	`deflate(int node)` It compresses the content of the node.This method takes the data of the NOM node, and does not include the element name or attributes of the NOM node.
`static void`	`delete(int node)` Deletes a single node and its children
`static void`	`delete(int from, int to)` Deletes the range of nodes specified in 'from' and 'to'
`static int`	`duplicate(int node)` Duplicates the specified node including all the child elements.
`static int`	`duplicate(int from, int to)` Deprecated. in C2. Use clone(int node, boolean deep).
`static int`	`duplicateAndAdd(int from, int to, int dest)` Duplicates and adds a range of nodes to the destination node.
`static int`	`duplicateAndAppend(int from, int to, int dest)` Duplicates and appends a range of nodes to most right sibling of the destination node.
`static int`	`duplicateAndAppendToChildren(int from, int to, int dest)` Duplicates and appends the range of nodes to the children of the destination node.
`static int`	`duplicateAndInsert(int from, int to, int dest)` Duplicates and inserts a range of nodes into the destination node.
`static int`	`duplicateAndInsertInChildren(int from, int to, int dest)` Duplicates and inserts the range of nodes into the children of the destination node.
`static int`	`duplicateElement(int element)` Duplicates an Element.
`static java.lang.String`	`getAttribute(int node, java.lang.String name)` Returns the value of the attribute for the specified attribute name of the given node, if the node is of type Element
`static java.lang.String`	`getAttribute(int node, java.lang.String name, java.lang.String defaultValue)` Returns the value of the given attribute, or the default value if the attribute does not exist
`static int`	`getAttributeInt(int node, java.lang.String name, int defaultValue)` Returns the value of the given attribute value as integer, or the default value if the attribute does not exist or is not an integer value.
`static java.lang.String`	`getAttributeLocalName(int node, int index)` Returns the local name of the attribute with the specified index in the node
`static java.lang.String`	`getAttributeName(int node, int index)` Returns the name of the attribute with the specified index in the node
`static java.lang.String`	`getAttributeNamespaceURI(int node, int index)` Returns the namespace URI associated with the namespace prefix of the attribute with the specified index in the node
`static java.lang.String`	`getAttributeNS(int node, java.lang.String name, java.lang.String uri)` Returns the value of the attribute for the specified attribute name which is bound with the given namespace URI of the given node, if the node is of type Element
`static java.lang.String`	`getAttributeNS(int node, java.lang.String name, java.lang.String uri, java.lang.String defaultValue)` Returns the value of the given attribute which is bound with the give URI, or the default value if the attribute does not exist
`static java.lang.String`	`getAttributePrefix(int node, int index)` Returns the namespace prefix of the attribute with the specified index in the node
`static int`	`getCompoundType(int node)` Returns the compound type of the node
`static java.lang.String`	`getData(int node)` Returns the data in the node, if it is of type Text, otherwise collects all data of all children nodes and returns that.
`static java.lang.String`	`getData(int node, java.lang.String defaultValue)` Deprecated. in C1, use getDataWithDefault()
`static byte[]`	`getDataBytesForElement(int node, java.lang.String tag, byte[] defaultValue)` Retrieves the data of the first child of node that has the specified tagname
`static byte[]`	`getDataBytesForElementWithNS(int node, java.lang.String tag, java.lang.String uri, byte[] defaultValue)` Retrieves the data of the first child of node that has the specified tagname and which is bound with the given namespace URI.
`static byte[]`	`getDataBytesWithDefault(int node, byte[] defaultValue)` Returns the data of the node in byte array, if it is of type Text, otherwise collects all data of all children nodes and returns that.
`static java.lang.String`	`getDataElement(int node, java.lang.String tag, java.lang.String defaultValue)` Retrieves the data of the first child of node that has the specified tagname.
`static java.lang.String`	`getDataElementNS(int node, java.lang.String tag, java.lang.String uri, java.lang.String defaultValue)` Retrieves the data of the first child of node that has the specified tagname and which is bound with the given namespace URI.
`static java.lang.String`	`getDataOfFirstDataChild(int node, java.lang.String defaultValue)` Deprecated. use getDataWithDefault(int node, String defaultValue) method.
`static int`	`getDataType(int node)` Returns the datatype of the node for which the attribute dt is set
`static java.lang.String`	`getDataWithDefault(int node, java.lang.String defaultValue)` Returns the data in the node, if it is of type Text, otherwise collects all data of all children nodes and returns that.
`static Document`	`getDocument(int node)` Returns a Document object to which the node belongs.
`static int`	`getElement(int node, java.lang.String tagName)` Returns a first child node with the given tag name.
`static int`	`getElementNS(int node, java.lang.String tagName, java.lang.String uri)` Returns a child node, with the given name which is bound with the given URI or 0.
`static int`	`getFirstChild(int node)` Returns the first child of the node.It can be either a data node or an element node.
`static int`	`getFirstChildElement(int node)` Returns the first child element of the node
`static int`	`getFirstDataNode(int node)` Returns the first child of node that is of type data
`static int`	`getFirstElement(int node)` Returns the first child of node which is of type element
`static int`	`getLastChild(int node)` Returns the last child of the node.It can be either a data node or an element node.
`static int`	`getLastChildElement(int node)` Returns the last child element of the node
`static java.lang.String`	`getLocalName(int node)` Returns the local name of the node.
`static java.lang.String`	`getName(int node)` Returns the tagname of the node, if it is of type element
`static java.lang.String`	`getNamespaceURI(int node)` Returns the namespace URI associated with the prefix of the element.
`static int`	`getNextElement(int node)` Returns the next (right) sibling element of the node
`static int`	`getNextSibling(int node)` Returns the next (right) sibling of the node.It can be either a data node or an element node.
`static int`	`getNumAttributes(int node)` Returns the number of attributes in the node, if it is of type element
`static int`	`getNumChildElements(int node)` Returns the number of child elements of the node
`static int`	`getNumChildren(int node)` Returns the number of children of the node.It counts both data nodes and element nodes.
`static int`	`getNumNextSiblingElements(int node)` Returns the number of sibling elements next to (on the right of) the node
`static int`	`getNumNextSiblings(int node)` Returns the number of siblings next to (on the right of) the node including elements and text
`static int`	`getNumPreviousSiblingElements(int node)` Returns the number of sibling elements previous to (on the left of) the node
`static int`	`getNumPreviousSiblings(int node)` Returns the number of siblings previous to (on the left of) the node including elements and text
`static int`	`getNumSiblingElements(int node)` Returns the number of sibling elements of the node
`static int`	`getNumSiblings(int node)` Returns the number of siblings of the node.It counts both data nodes and element nodes.
`static int`	`getParent(int node)` Returns the parent node reference of the given node reference
`static java.lang.String`	`getPrefix(int node)` Returns the prefix of the tag name of the element.
`static int`	`getPreviousElement(int node)` Returns the previous (left) sibling element of the node
`static int`	`getPreviousSibling(int node)` Returns the previous (left) sibling of the node.It can be either a data node or an element node.
`static int`	`getRoot(int node)` Returns the root node of the node (DOM: document element).
`static int`	`getType(int node)` Returns the type of the node
`static int`	`insert(int node, int dest)` Inserts the given node into the destination node.
`static int`	`insert(int from, int to, int dest)` Inserts a range of nodes into the destination node.
`static int`	`insertInChildren(int from, int to, int dest)` Inserts the range of nodes into the children of the destination node.
`static boolean`	`isValidNode(int supposedNode)` Determines whether the supposed node is a valid node or not.
`static int`	`listCompare(int from1, int to1, int from2, int to2, int depth, int flags)` Compares two lists of XML nodes for equality
`static boolean`	`nameEquals(int node, java.lang.String name)` Checks whether the name of the node is equal to the given 'name'.
`static int`	`removeAttribute(int node, java.lang.String name)` Removes the attribute with the specified name in the node, and returns the result of this action (0 if succeeded).
`static int`	`removeAttributeNS(int node, java.lang.String name, java.lang.String URI)` Removes the attribute with the specified name & URI in the node, and returns the result of this action (0 if succeeded).
`static int`	`removeAttributesRecursive(int node, java.lang.String name1, java.lang.String name2, java.lang.String name3, java.lang.String name4)` Removes the attributes with the specified names recursively from the node and children, and returns the result of this action (0 if succeeded).
`static int`	`rewriteTextElement(int node, java.lang.String tag, java.lang.String data)` Deprecated. in C2. Use setDataElement(int node, String tag, String data).
`static void`	`setAttribute(int node, java.lang.String name, java.lang.String value)` Sets the attribute in the node, if it is of type element
`static void`	`setAttributeNS(int node, java.lang.String name, java.lang.String uri, java.lang.String value)` Sets the attribute which is bound with the given URI in the node, if it is of type element.
`static void`	`setCDataBytesForElement(int node, java.lang.String tag, byte[] data)` Finds a first level child element of 'node' by name 'tag' and replaces the CData section by the given 'data'.
`static int`	`setCDataElement(int node, java.lang.String tag, java.lang.String data)` Finds a first level child element of 'node' by name 'tag' and replaces the CData section by the given 'data'.
`static void`	`setData(int node, java.lang.String data)` Sets the data in the node, if it is of type Text
`static void`	`setDataBytes(int node, byte[] data)` Sets the given data in the node
`static void`	`setDataBytesForElement(int node, java.lang.String tag, byte[] data)` Rewrites the data children of the element 'node' to have a new element as last child with 'tag' as element name .
`static void`	`setDataBytesForElementWithNS(int node, java.lang.String tag, java.lang.String uri, byte[] data)` Rewrites the data children of the element 'node' to have a new element as last child with 'tag' as element name and binds with the given namespace URI.
`static int`	`setDataElement(int node, java.lang.String tag, java.lang.String data)` Rewrites the data children of the element 'node' to have a new element as last child with 'tag' as element name .
`static int`	`setDataElementNS(int node, java.lang.String tag, java.lang.String uri, java.lang.String data)` Rewrites the data children of the element 'node' to have a new element as last child with 'tag' as element name and binds with the given namespace URI.
`static void`	`setName(int node, java.lang.String name)` Sets the tagname of the node, if it is of type element
`static int`	`setNSDefinition(int node, java.lang.String prefix, java.lang.String uri)` Set the namespace definition to the node.
`static int`	`setNSPrefix(int node, java.lang.String prefix)` Set the namespace prefix to the node.
`static int`	`setNSPrefixRecursive(int node, java.lang.String oldPrefix, java.lang.String newPrefix)` Set the old namespace prefix to the new namespace prefix recursively to the given node and its children.
`static int`	`unlink(int node)` Unlinks a given node and it children from the tree it is in
`static int`	`unlink(int from, int to)` Unlinks a range of nodes from the tree they are in
`static byte[]`	`write(int node, boolean pretty)` Writes the contents of the node into the byte-array
`static byte[]`	`write(int from, int to, int pretty)` Writes the given range of nodes to byte-array
`static void`	`writeToFile(int from, int to, java.lang.String file, int pretty)` Writes a range of nodes to a file.
`static java.lang.String`	`writeToString(int node, boolean pretty)` Writes the contents of the node into the string
`static java.lang.String`	`writeToStringWithNSInfo(int node, boolean pretty)` Writes the contents of the node with namespace information(defined in ancestor node)into the string
`static byte[]`	`writeWithNSInfo(int from, int to, int pretty)` Writes the given range of nodes to byte-array with namespace information(defined in ancestor node)

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- WRITE_NORMAL
```
public static final int WRITE_NORMAL
```
  Use this constant when you want to do normal serialization in Node.write()
  
  See Also:
  
  Constant Field Values
- WRITE_PRETTY
```
public static final int WRITE_PRETTY
```
  Use this constant when you want to do pretty serialization in Node.write()
  
  See Also:
  
  Constant Field Values
- WRITE_HEADER
```
public static final int WRITE_HEADER
```
  Use this constant when you want to include xml header while serialization in Node.writeToFile()
  
  See Also:
  
  Constant Field Values

Method Detail

isValidNode
```
public static boolean isValidNode(int supposedNode)
```
Determines whether the supposed node is a valid node or not.

listCompare

public static int listCompare(int from1,
                              int to1,
                              int from2,
                              int to2,
                              int depth,
                              int flags)

Compares two lists of XML nodes for equality

Parameters:

from1 - the start reference of the first set of nodes

to1 - the end reference of the first set of nodes

from2 - the start reference of the second set of nodes

to2 - the end reference of the second set of nodes

depth - depth until which to compare

flags - This specifies the behavior of the comparison
         Specify 0 to compare both attributes and data of the specified node.
         Specify 1 to exclude data from comparison.
         Specify 2 to exclude attributes from comparison.
         Specify 8 to include Namespace information. i.e, comparison based on URIs, not on prefixes.
         Specify 128 for SemanticalIn operation.
         Specifiy 256 for SemanticalEqual operation.

Returns:

Returns 0, if the XML nodes are matched.
Returns 1, if the XML nodes do not match.
Note :"flag" can get combination of the above values.Except SemanticalIn and SemanticalEqual can't be used together. See Example for how to use.

Example:

flags = 0 (compare attribute and data)

  String xml1 = "<root><ele1 att1=\"att1\">data1</ele1></root>";
 String xml2 = "<root><ele1 att1=\"att1\">data1</ele1></root>";
 try{
        int root1 = doc.parseString(xml1); int root2 = doc.parseString(xml2);
        int flag = Node.listCompare(root1, root1, root2, root2, 0, 0);
        //Input nodes are matched for equality even though data of <ele1> is different for both input xml.
 }catch(Exception e){
        e.printStackTrace();
 }

flags = 1 (Exclude data)

  String xml1 = "<root><ele1 att1=\"att1\">data1</ele1></root>";
 String xml2 = "<root><ele1 att1=\"att1\">data2</ele1></root>";
 try{
        int root1 = doc.parseString(xml1); int root2 = doc.parseString(xml2);
        int flag = Node.listCompare(root1, root1, root2, root2, 0, 1);
        //Input nodes are matched for equality even though data of <ele1> is different for both input xml.
 }catch(Exception e){
        e.printStackTrace();
 }

flags = 2 (Exclude attribute)

  String xml1 = "<root><ele1 att1=\"att1\">data1</ele1></root>";
 String xml2 = "<root><ele1 att1=\"att2\">data1</ele1></root>";
 try{
        int root1 = doc.parseString(xml1); int root2 = doc.parseString(xml2);
        int flag = Node.listCompare(root1, root1, root2, root2, 0, 2);
        //Input nodes are matched for equality even though values of "attr1"is different for both input xml.
 }catch(Exception e){
        e.printStackTrace();
 }

flags = 8 (Include Namespace information)

  String xml1 = "<p:root xmlns:p=\"http://www.w3.org/TR/html4/\"><p:ele1 att1=\"att1\">data1</p:ele1></p:root>";
 String xml2 = "<q:root xmlns:q=\"http://www.w3.org/TR/html4/\"><q:ele1 att1=\"att1\">data1</q:ele1></q:root>";
 try{
        int root1 = doc.parseString(xml1); int root2 = doc.parseString(xml2);
        int flag = Node.listCompare(root1, root1, root2, root2, 0, 8);
        //Input nodes are matched for equality even though prefixes are different.
 }catch(Exception e){
        e.printStackTrace();
 }

flags = 128 (Semantical Inclusive). xml2 should contain all the data of xml1. We can say xml1 is a subset of xml2.

  String xml1 = "<root><row><col1>Apples</col1><col2>Bananas</col2></row></root>";
 String xml2 = "<root><row><col1>Apples</col1><col2>Bananas</col2><col3>Oranges</col3></row></root>";
 try{
        int root1 = doc.parseString(xml1); int root2 = doc.parseString(xml2);
        int flag = Node.listCompare(root1,0,root2,0,0,128);
        //Input nodes are matched for equality even though the order of child elements are different.
 }catch(Exception e){
        e.printStackTrace();
 }

flags = 256 (Semantical Equal)

  String xml1 = "<root><row><col1>Apples</col1><col2>Bananas</col2></row></root>";
 String xml2 = "<root><row><col1>Apples</col1><col2>Bananas</col2></row></root>";
 try{
        int root1 = doc.parseString(xml1); int root2 = doc.parseString(xml2);
        int flag = Node.listCompare(root1,0,root2,0,0,128);
 //Input nodes are matched for equality.
 }catch(Exception e){
        e.printStackTrace();
 }

flags = 136 (128 + 8) (Semantical Inclusive + Include Namespace information)

  String xml1 = "<p:root xmlns:p=\"http://www.w3.org/TR/html4/\"><p:row><p:col1>Apples</p:col1><p:col2>Bananas</p:col2></p:row></p:root>";
 String xml2 = "<q:root xmlns:q=\"http://www.w3.org/TR/html4/\"><q:row><q:col1>Bananas</q:col1><q:col2>Apples</q:col2><q:col3>Oranges</q:col3></q:row></q:root>";
 try{
        int root1 = doc.parseString(xml1); int root2 = doc.parseString(xml2);
        int flag = Node.listCompare(root1,0,root2,0,0,136);
 //Input nodes are matched for equality.
 }catch(Exception e){
        e.printStackTrace();
 }

Throws:

XMLException

getPrefix
```
public static java.lang.String getPrefix(int node)
```
Returns the prefix of the tag name of the element. This is the part of the tagname before the first colon. Returns null if the prefix is not available.
Parameters:

node - The XML element for which the prefix is required

Returns:
The namespace prefix value if available, otherwise it returns null.

Example:
```
 
      int element = document.load("<prefix:element xmlns:prefix=\"http://cordys.com/test\"/>".getBytes());
      Node.getPrefix(element);
      // returns "prefix"
 
 
```

getLocalName
```
public static java.lang.String getLocalName(int node)
```
Returns the local name of the node. This is the part of the tagname that follows the first colon.Returns null if the node is invalid.
Parameters:

node - The XML element for which the localname is required

Returns:
The localname of the element.

Example:
```
 
      int element = document.load("<prefix:element xmlns:prefix=\"http://cordys.com/test\"/>".getBytes());
      Node.getLocalName(element);
      // returns "element"
 
 
```

getNamespaceURI

public static java.lang.String getNamespaceURI(int node)

Returns the namespace URI associated with the prefix of the element. If there is no prefix ,then it returns the default namespace URI if it is available. It returns null if there is no prefix and no default namespace associated with the element.

Parameters:

node - The XML element for which the namespace URI is required.

Returns:

The namespace URI of the element if available, otherwise it returns null.

Example:

 
      int element = 0;
      try {
      element = document.load("<prefix:element xmlns:prefix=\"http://cordys.com/test\"/>".getBytes());
      String namespace = Node.getNamespaceURI(element); // returns "http://cordys.com/test"
 
      element = document.load("<element xmlns=\"http://cordys.com/test\"/>".getBytes());
      namespace = Node.getNamespaceURI(element); // returns "http://cordys.com/test"
 
      element = document.load("<element/>".getBytes());
      namespace = Node.getNamespaceURI(element); // returns null
 
      element = document.load("<element xmlns=\"test\"><child><grandchild xmlns=\"\"/></child></element>".getBytes());
      int childElement  = Node.getFirstChild(element);
      int grandchildElement = Node.getFirstChild(childElement);
      namespace = Node.getNamespaceURI(grandchildElement); // returns null
      }
      finally {
      Node.delete(element);
      }

getRoot

public static int getRoot(int node)

Returns the root node of the node (DOM: document element).

Parameters:

node - The XML element reference.

Returns:

The root element node reference.

Example:

 
 String xmlStr = "<root xmlns:h=\"http://www.w3.org/TR/html4\" ><h:table></h:table></root>";
 try {
        int result = document.load(xmlStr.getBytes());
        result = Node.getFirstChildElement(result);
        result = Node.getRoot(result);
        assertEquals("root", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

rewriteTextElement
```
@Deprecated
public static int rewriteTextElement(int node,
                                                  java.lang.String tag,
                                                  java.lang.String data)
```
Deprecated. in C2. Use setDataElement(int node, String tag, String data).

Rewrites the data children of the elements that are a child of node that have tag as tagname.

Parameters:

node - The XML element reference

tag - The tagname of the element to be rewritten

data - The data of the element that is to be rewritten for the matched element with the given tag name.

Returns:

0 if success, negative number if failure

setDataElement
```
public static int setDataElement(int node,
                                 java.lang.String tag,
                                 java.lang.String data)
```
Rewrites the data children of the element 'node' to have a new element as last child with 'tag' as element name . If the tag name is not given, then it will set the data to the given element itself.
Parameters:

node - XML element from which the operation starts

tag - element to be operated, if empty, then 'node' will be operated

data - data to be added

Returns:
0 if success, negative number if failure

Example:
```
 
 int element = document.load("<element/>".getBytes());
 Node.setDataElement(element, "childElement", "value");
 // This will change the element node as
 //   <element>
 //       <childElement>value</childElement>
 //   </element>
 
 
```

setDataElementNS

public static int setDataElementNS(int node,
                                   java.lang.String tag,
                                   java.lang.String uri,
                                   java.lang.String data)

Rewrites the data children of the element 'node' to have a new element as last child with 'tag' as element name and binds with the given namespace URI. If the tag name is not given, then it will set the data to the given element itself. If the given URI is not defined, it will create a default namespace with the given URI.

Parameters:

node - XML element from which the operation starts

tag - element to be operated, if empty, then 'node' will be operated

uri - The namespace URI.

data - data to be added

Returns:

0 if success, negative number if failure

Example:

 
   
 int element = document.load("<element xmlns:ns=\"http://cordys.com/test\"/>".getBytes("UTF-8"));
 Node.setDataElementNS(element,"childElement", "http://cordys.com/test", "value");
 //The result will be as below
 <element
 	xmlns:ns="http://cordys.com/test">
 	<childElement
 		xmlns="http://cordys.com/test">value
 	</childElement>
 </element>
 
 
 int element = document.load("<element/>".getBytes("UTF-8"));
 Node.setDataElementNS(element,"childElement", "http://cordys.com/test", "value");
 //The result will be as below
 <element>
 	<childElement
 		xmlns="http://cordys.com/test">value</childElement>
 </element>
 
 
 
 int element = document.load("<element/>".getBytes("UTF-8"));
 Node.setDataElementNS(element,"", "http://cordys.com/test", "value");
 //The result will be as below
 <element>value</element>

setCDataElement

public static int setCDataElement(int node,
                                  java.lang.String tag,
                                  java.lang.String data)

Finds a first level child element of 'node' by name 'tag' and replaces the CData section by the given 'data'. If 'tag' element has child elements, then all the children are removed and only 'data' in the CData section exists.

Parameters:

node - XML element from which the operation starts

tag - element to be operated, if empty, then 'node' will be operated

data - data to be added

Returns:

0 if success, negative number if failure

Example:

 
  String xml =
 "<root>
        <employee> Cordys employee </employee>
        <employee1>
                <test> Cordys employee </test>
        </employee1>
 </root>";
 
 int root = document.load(xml.getBytes("UTF-8"));
 
 // Changes 'employee' value from "Cordys employee" to "<![CDATA[testing data]]>"
  Node.setCDataElement(root,"employee","testing data");
 
 // Removes 'test' from 'employee1', and adds "<![CDATA[testing data]]>" to 'employee1'
  Node.setCDataElement(root,"employee1","testing data");
 
 // Changes 'employee' value from "Cordys employee" to "<![CDATA[testing data]]>"
 int emp = Node.getFirstChild(root);
 Node.setCDataElement(emp,"","testing data");

createElement

public static int createElement(java.lang.String tag,
                                int parent)

Creates a new element with the given tag and appends it to parent. If parent is 0, the element will not be created.
Note : This method can't be used before creating a Document object

Parameters:

tag - The tag for the new element

parent - The parent for the new element

Returns:

returns the created element node reference

Example:

 
 Document oDocument = new Document();
 String xmlStr = "<root xmlns:h=\"http://www.w3.org/TR/html4\" ><h:table></h:table></root>";
 try {
        int result = oDocument.load(xmlStr.getBytes());
        Node.createElement("chair", result);
        result = Node.getLastChildElement(result);
        assertEquals("chair", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

createTextElement

public static int createTextElement(java.lang.String tag,
                                    java.lang.String text,
                                    int parent)

Creates a new element, appends it to parent, and creates a new text node which is appended to the newly created element. If parent is 0, the element will not be created.
Note : This method can't be used before creating a Document object

Parameters:

tag - The tag for the new element

text - The data for the new node

parent - The parent for the new element

Returns:

returns the created element node reference

Example:

 
 Document oDocument = new Document();
 String xmlStr = "<root xmlns:h=\"http://www.w3.org/TR/html4\" ><h:table></h:table></root>";
 try {
        int result = oDocument.load(xmlStr.getBytes());
        Node.createTextElement("chair", "createdText", result);
        result = Node.getLastChildElement(result);
        assertEquals("chair", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

createCDataElement

public static int createCDataElement(java.lang.String tag,
                                     java.lang.String text,
                                     int parent)

Creates a new CDATA element by name 'tag' with 'text' as CData section, and appends it to 'parent'.
Note : This method can't be used before creating a Document object

Parameters:

tag - The tag for the new element

text - The CData for the new node

parent - The parent for the new element

Returns:

returns the created element node reference

Example:

 
 Document oDocument = new Document();
 String xmlStr = "<root xmlns:h=\"http://www.w3.org/TR/html4\" ><h:table></h:table></root>";
 try {
        int result = oDocument.load(xmlStr.getBytes());
        Node.createCDataElement("chair", "createdText", result);
        result = Node.getLastChildElement(result);
        assertEquals("<chair><![CDATA[createdText]]></chair>", Node.writeToString(
                        result, false));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getDataElement

public static java.lang.String getDataElement(int node,
                                              java.lang.String tag,
                                              java.lang.String defaultValue)

Retrieves the data of the first child of node that has the specified tagname.

Parameters:

node - The element reference

tag - The tag name of the element

defaultValue - That is to be returned if the given element tag is not available or the data to the element is not available.

Returns:

The data of the given element. If the data is not available, defaultValue will be returned.

Example:

         
         int element = document.load("<element><childElement>value</childElement></element>".getBytes());
         String data = Node.getDataElement(element, "childElement", "noData"); // returns value
         data = Node.getDataElement(element, "someElement", "noData"); // returns noData

getDataElementNS

public static java.lang.String getDataElementNS(int node,
                                                java.lang.String tag,
                                                java.lang.String uri,
                                                java.lang.String defaultValue)

Retrieves the data of the first child of node that has the specified tagname and which is bound with the given namespace URI.

Parameters:

node - The element reference

tag - The tag name of the element

uri - The namespace URI of the element

defaultValue - That is to be returned if the given element tag is not available or the data to the element is not available.

Returns:

The data of the given element. If the data is not available, defaultValue will be returned.

Example:

         
         int element = document.load("<element xmlns:ns=\"http://cordys.com/test\"><ns:childElement>value</ns:childElement></element>".getBytes());
         String data = Node.getDataElementNS(element, "childElement", "http://cordys.com/test", "noData"); // returns value
         data = Node.getDataElementNS(element, "childElement", "http://cordys.com/test1", "noData") // returns noData
         data = Node.getDataElementNS(element, "childElement1", "http://cordys.com/test", "noData") // returns noData

delete

public static void delete(int from,
                          int to)

Deletes the range of nodes specified in 'from' and 'to'

Parameters:

from - The start element reference for delete

to - The end element reference for delete

Example:

 
 Document oDocument = new Document();
 String xmlStr = "<root><table></table><chair/></root>";
 try {
        int result = oDocument.load(xmlStr.getBytes());
        int from = Node.getFirstChild(result);
        int to = Node.getLastChild(result);
        Node.delete(from, to);
        assertEquals("<root/>", Node.writeToString(result, false));
 } catch (XMLException e) {
        e.printStackTrace();
 }

delete

public static void delete(int node)

Deletes a single node and its children

Parameters:

node - The element reference to be deleted

Example:

 
 Document oDocument = new Document();
 String xmlStr = "<root xmlns:h=\"http://www.w3.org/TR/html4\" ><h:table></h:table><chair/></root>";
 try {
        int result = oDocument.load(xmlStr.getBytes());
        Node.delete(Node.getLastChildElement(result));
        result = Node.getLastChildElement(result);
        assertEquals("h:table", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

captureTaceInMap

public static void captureTaceInMap(int node)

unlink

public static int unlink(int from,
                         int to)

Unlinks a range of nodes from the tree they are in

Parameters:

from - The start element reference for delete

to - The end element reference for delete

Returns:

The from node reference if unlinked successfully, 0 on error

Example:

 
 Document oDocument = new Document();
 String xmlStr = "<root><table></table><chair/><bench/></root>";
 try {
        int result = oDocument.load(xmlStr.getBytes());
        int child1 = Node.getFirstChildElement(result);
        int child2 = Node.getNextSibling(child1);
        Node.unlink(child1, child2);
        result = Node.getFirstChildElement(result);
        assertEquals("bench", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

unlink

public static int unlink(int node)

Unlinks a given node and it children from the tree it is in

Parameters:

node - The element reference to be unlinked.

Returns:

The node reference if unlinked successfully, 0 on error

Example:

 
 Document oDocument = new Document();
 String xmlStr = "<root><table></table><chair/><bench/></root>";
 try {
        int result = oDocument.load(xmlStr.getBytes());
        int child1 = Node.getFirstChildElement(result);
        Node.unlink(child1);
        result = Node.getFirstChildElement(result);
        assertEquals("chair", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

insert
```
public static int insert(int from,
                         int to,
                         int dest)
```
Inserts a range of nodes into the destination node. (i.e. they will be the immediate left siblings)
Parameters:

from - The start element reference to be inserted.

to - The end element reference to be inserted. If from and to are same, only that node will be inserted. If to is specified as 0, all siblings of 'from' will be inserted

dest - The destination node reference forwhich the range of elements are inserted as immediate left siblings

Returns:
The element reference of the destination node.

Example:
```
 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.insert(newelement, newelement, Node.getFirstChild(root));
 // After this operation, root element will be as shown below
 //   <root>
 //       <newElement>value</newElement>
 //       <element1/>
 //       <element2/>
 //   </root>
 
 
```

insert

public static int insert(int node,
                         int dest)

Inserts the given node into the destination node. (i.e. it will be the immediate left sibling)

Parameters:

node - The element reference to be inserted.

dest - The destination node reference forwhich the given element is inserted as immediate left sibling

Returns:

The element reference of the destination node.

Example:

 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.insert(newelement, Node.getFirstChild(root));
 // After this operation, root element will be as shown below
 //   <root>
 //       <newElement>value</newElement>
 //       <element1/>
 //       <element2/>
 //   </root>

add
```
public static int add(int from,
                      int to,
                      int dest)
```
Adds a range of nodes to the destination node. (i.e. they will be the immediate right siblings)
Parameters:

from - The start element reference to be added.

to - The end element reference to be added. If from and to are same, only that node will be added. If to is specified as 0, all siblings of 'from' will be added

dest - The destination node reference forwhich the range of elements are added as immediate right siblings

Returns:
The element reference of the destination node.

Example:
```
 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.add(newelement, newelement, Node.getFirstChild(root));
 // After this operation, root element will be as shown below
 //   <root>
 //       <element1/>
 //       <newElement>value</newElement>
 //       <element2/>
 //   </root>
 
 
```

add

public static int add(int node,
                      int dest)

Adds the specified node to the destination node. (i.e. the node added will be the immediate right sibling)

Parameters:

node - The element reference to be added.

dest - The destination node reference forwhich the given element is added as immediate right sibling

Returns:

The element reference of the destination node.

Example:

 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.add(newelement, Node.getFirstChild(root));
 // After this operation, root element will be as shown below
 //   <root>
 //       <element1/>
 //       <newElement>value</newElement>
 //       <element2/>
 //   </root>

append
```
public static int append(int from,
                         int to,
                         int dest)
```
Appends a range of nodes to most right sibling of the destination node.
Parameters:

from - The start element reference to be appended.

to - The end element reference to be appended. If from and to are same, only that node will be appended. If to is specified as 0, all siblings of 'from' will be appended.

dest - The destination node reference forwhich the range of elements are appended as immediate right siblings

Returns:
The element reference of the destination node.

Example:
```
 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.append(newelement, newelement, Node.getFirstChild(root));
 // After this operation, root element will be as shown below
 //   <root>
 //       <element1/>
 //       <element2/>
 //       <newElement>value</newElement>
 //   </root>
 
 
```

append

public static int append(int node,
                         int destination)

Appends the specified node to most right sibling of the destination node.

Parameters:

node - The element reference to be appended.

destination - The destination node reference forwhich the given element is appended as immediate right sibling

Returns:

The element reference of the destination node.

Example:

 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.append(newelement, Node.getFirstChild(root));
 // After this operation, root element will be as shown below
 //   <root>
 //       <element1/>
 //       <element2/>
 //       <newElement>value</newElement>
 //   </root>

insertInChildren
```
public static int insertInChildren(int from,
                                   int to,
                                   int dest)
```
Inserts the range of nodes into the children of the destination node. (i.e. the range will be the set of left siblings of the first child of the destination node).
Parameters:

from - The start element reference to be inserted.

to - The end element reference to be inserted. If from and to are same, only that node will be inserted. If to is specified as 0, all siblings of 'from' will be inserted.

dest - The destination node reference forwhich the range of elements are inserted as child elements

Returns:
The element reference of the destination node.

Example:
```
 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.insertInChildren(newelement, newelement, root);
 // After this operation, root element will be as shown below
 //   <root>
 //       <newElement>value</newElement>
 //       <element1/>
 //       <element2/>
 //   </root>
 
 
```

appendToChildren
```
public static int appendToChildren(int from,
                                   int to,
                                   int dest)
```
Appends the range of nodes to the children of the destination node. (i.e. the range will be the set of right siblings of the last child of the destination node).
Parameters:

from - The start element reference to be appended.

to - The end element reference to be appended. If from and to are same, only that node will be appended. If to is specified as 0, all siblings of 'from' will be appended.

dest - The destination node reference

Returns:
The element reference of the destination node.

Example:
```
 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.appendToChildren(newelement, newelement, root);
 // After this operation, root element will be as shown below
 //   <root>
 //       <element1/>
 //       <element2/>
 //       <newElement>value</newElement>
 //   </root>
 
 
```

appendToChildren

public static int appendToChildren(int node,
                                   int destination)

Appends the specified node to the children of the destination node. (i.e. the given node will be the last child of the destination node).

Parameters:

node - The element reference to be appended.

destination - The destination node reference

Returns:

The element reference of the destination node.

Example:

 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.appendToChildren(newelement, root);
 // After this operation, root element will be as shown below
 //   <root>
 //       <element1/>
 //       <element2/>
 //       <newElement>value</newElement>
 //   </root>

clone

public static int clone(int node,
                        boolean deep)

Returns a clone of the node. If deep==true then this will create clone of all the child elements. If deep==false then this will create clone of the given element only, not its children elements.

Parameters:

node - The element reference to be cloned.

deep - The boolean variable indicates whether to clone child elements of the given node.

Returns:

The cloned element reference if success, 0 on error.

Example:

 
 int element = document
                .load("<element><childElement><node>value</node></childElement></element>"
                                .getBytes());
 cloneElement = Node.clone(element, true);
 // returns
 //   <element>
 //       <childElement>
 //          <node>value</node>
 //       </childElement>
 //   </element>
 
 cloneElement = Node.clone(element, false);
 // returns
 //   </element>

duplicate
```
@Deprecated
public static int duplicate(int from,
                                         int to)
```
Deprecated. in C2. Use clone(int node, boolean deep).

Duplicates a range of nodes

Parameters:

from - The element reference of node from which to duplicate

to - The element reference of the node to which to duplicate

Returns:

The first node reference which is duplicated.

duplicateElement

public static int duplicateElement(int element)

Duplicates an Element. It does not duplicate the child elements of the given element. It duplicates the only top level element with all the attributes.

Parameters:

element - The reference of node to duplicate

Returns:

The duplicated node reference.

Example:

 
      int element = document.load("<element att=\"value\"><childElement><node>value</node></childElement></element>".getBytes());
      duplElement = Node.duplicateElement(element);
      // returns
      //   </element att="value">

duplicate

public static int duplicate(int node)

Duplicates the specified node including all the child elements.

Parameters:

node - int reference of node which is to be duplicated

Returns:

The duplicated node reference

Example:

 
      int element = document.load("<element att=\"value\"><childElement><node>value</node></childElement></element>".getBytes());
      duplElement = Node.duplicate(element);
      // returns
      //   <element att="value">
      //       <childElement>
      //          <node>value</node>
      //       </childElement>
      //   </element>

duplicateAndInsert

public static int duplicateAndInsert(int from,
                                     int to,
                                     int dest)

Duplicates and inserts a range of nodes into the destination node. (i.e. they will be the immediate left siblings)

Parameters:

from - int reference of the node from which to duplicate

to - If from and to are same only that node will be duplicated and inserted if to is specified as 0 all siblings will be duplicated and inserted

dest - the destination node reference

Returns:

The destination node reference.

Example:

 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.duplicateAndInsert(newelement, newelement, Node.getFirstChild(root));
 // After this operation, root element will be as shown below
 //   <root>
 //       <newElement>value</newElement>
 //       <element1/>
 //       <element2/>
 //   </root>

duplicateAndAdd

public static int duplicateAndAdd(int from,
                                  int to,
                                  int dest)

Duplicates and adds a range of nodes to the destination node. (i.e. they will be the immediate right siblings)

Parameters:

from - int reference of the node which is to be duplicated and inserted

to - If from and to are same only that node will be duplicated and inserted if to is specified as 0 all siblings will be duplicated and inserted

dest - the destination node reference to be inserted

Returns:

The destination node reference

Example:

 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.duplicateAndAdd(newelement, newelement, Node.getFirstChild(root));
 // After this operation, root element will be as shown below
 //   <root>
 //       <element1/>
 //       <newElement>value</newElement>
 //       <element2/>
 //   </root>

duplicateAndAppend

public static int duplicateAndAppend(int from,
                                     int to,
                                     int dest)

Duplicates and appends a range of nodes to most right sibling of the destination node.

Parameters:

from - int reference of the node which is to be duplicated

to - If from and to are same only that node will be duplicated and appended if to is specified as 0 all siblings will be duplicated and appended

dest - the destination node reference

Returns:

The destination node reference

Example:

 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.duplicateAndAppend(newelement, newelement, Node.getFirstChild(root));
 // After this operation, root element will be as shown below
 //   <root>
 //       <element1/>
 //       <element2/>
 //       <newElement>value</newElement>
 //   </root>

duplicateAndInsertInChildren
```
public static int duplicateAndInsertInChildren(int from,
                                               int to,
                                               int dest)
```
Duplicates and inserts the range of nodes into the children of the destination node. (i.e. the range will be the set of left siblings of the first child of the destination node).
Parameters:

from - the start node reference which is to be duplicated

to - the end node reference to be duplicated. If from and to are same only that node will be duplicated and inserted. If it is specified as 0 all siblings will be duplicated and inserted

dest - int reference of the node in which to insert

Returns:
The destination node reference.

Example:
```
 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.duplicateAndInsertInChildren(newelement, newelement, root);
 // After this operation, root element will be as shown below
 //   <root>
 //       <newElement>value</newElement>
 //       <element1/>
 //       <element2/>
 //   </root>
 
 
```

duplicateAndAppendToChildren

public static int duplicateAndAppendToChildren(int from,
                                               int to,
                                               int dest)

Duplicates and appends the range of nodes to the children of the destination node. (i.e. the range will be the set of right siblings of the last child of the destination node).

Parameters:

from - int reference of the node which is to be duplicated

to - If from and to are same, only that node will be duplicated and appended if to is specified as 0 all siblings will be duplicated and appended

dest - int reference of the node in which to insert

Returns:

The destination node reference.

Example:

 
 int root = document.parseString("<root><element1/><element2/></root>");
 int newelement = document.parseString("<newElement>value</newElement>");
 Node.duplicateAndAppendToChildren(newelement, newelement, root);
 // After this operation, root element will be as shown below
 //   <root>
 //       <element1/>
 //       <element2/>
 //       <newElement>value</newElement>
 //   </root>

setName

public static void setName(int node,
                           java.lang.String name)

Sets the tagname of the node, if it is of type element

Parameters:

node - The element reference for which the tagname needs to be changed.

name - The new tag name.

Example:

 
 int element = document.load("<oldelement/>".getBytes());
 Node.setName(element, "newelement");
 //"oldelement" gets changed to "newelement"

getName

public static java.lang.String getName(int node)

Returns the tagname of the node, if it is of type element

Parameters:

node - The element reference for which the tagname is required.

Returns:

The tagname of the node.

Example:

 
 int element = document.load("<element/>".getBytes());
 String tagName = Node.getName(element);
 // returns 'element'

setData

public static void setData(int node,
                           java.lang.String data)

Sets the data in the node, if it is of type Text

Parameters:

node - The data element reference for which the data needs to set

data - The string data that is to be set.

Example:

 
 int element = document.load("<element>data</element>".getBytes());
 Node.setData(Node.getFirstChild(element), "data-modified");
 // The element node will be <element>data-modified</element>

getData
```
@Deprecated
public static java.lang.String getData(int node,
                                                    java.lang.String defaultValue)
```
Deprecated. in C1, use getDataWithDefault()

Returns the data in the node, if it is of type Text, otherwise collects all data of all children nodes and returns that. If there is no data in the node or its children, the defaultValue is returned.

Parameters:

node - The text element reference

defaultValue - The value that is to be returned if the data is not found to the given text element

Returns:

The data of the node or its children, or the default value.

getDataWithDefault

public static java.lang.String getDataWithDefault(int node,
                                                  java.lang.String defaultValue)

Returns the data in the node, if it is of type Text, otherwise collects all data of all children nodes and returns that. If there is no data in the node or its children, the defaultValue is returned.

Parameters:

node - The text element reference

defaultValue - The value that is to be returned if the data is not found to the given text element

Returns:

The data of the node or its children, or the default value.

Example:

 
 int element = document.load("<element>data</element>".getBytes());
 String data = Node.getDataWithDefault(element, "default");
 //returns "data"
 int element = document.load("<element></element>".getBytes());
 String data = Node.getDataWithDefault(element, "default");
 //returns "default"

getData
```
public static java.lang.String getData(int node)
```
Returns the data in the node, if it is of type Text, otherwise collects all data of all children nodes and returns that.
Parameters:

node - The text element reference

Returns:
The data of the node if available

Example:
```
 
 int element = document.load("<element>data</element>".getBytes());
 String data = Node.getData(Node.getFirstChild(element));
 //returns "data"
 
 
```

getDataOfFirstDataChild
```
@Deprecated
public static java.lang.String getDataOfFirstDataChild(int node,
                                                                    java.lang.String defaultValue)
```
Deprecated. use getDataWithDefault(int node, String defaultValue) method.

Returns the value of the first data node that is a child of node. If node is 0 or has no children, the defaultValue will be returned.

Parameters:

node - The node element reference.

defaultValue - The value that is to be returned if the data is not found to the first child of given element

Returns:

The data of the node of the first child, or the default value.

setAttribute

public static void setAttribute(int node,
                                java.lang.String name,
                                java.lang.String value)

Sets the attribute in the node, if it is of type element

Parameters:

node - The reference of the node

name - The name of the attribute

value - The value for the attribute

Example:

 
 int element = document.load("<element/>".getBytes());
 Node.setAttribute(element, "attributename", "attributeValue");
 // The element node will look like
 //   <element attributename="attributeValue"/>

setAttributeNS
```
public static void setAttributeNS(int node,
                                  java.lang.String name,
                                  java.lang.String uri,
                                  java.lang.String value)
```
Sets the attribute which is bound with the given URI in the node, if it is of type element. i.e If the URI is bound to a namespace then the relevant prefix(if any) will be attached to the attribute.If the given URI is not defined to any prefix, then it will create a default namespace with the given URI.It allows attribute name with prefix.But it doesn't check if the prefix has namespace binding(validity of the resultant xml is not guaranteed).
Parameters:

node - The reference of the node

name - The name of the attribute

uri - The namespace URI.
value - The value for the attribute

Example:
```
 
      int element = document.load("<element xmlns:ns=\"http://cordys.com/test\"/>".getBytes());
      Node.setAttributeNS(element,"attributename","http://cordys.com/test","attributeValue");
      // The element node will look like
      //   <element ns:attributename="attributeValue"/>
 
 
```

setNSDefinition
```
public static int setNSDefinition(int node,
                                  java.lang.String prefix,
                                  java.lang.String uri)
```
Set the namespace definition to the node. If the namespace is already defined to the node with the given prefix, It will modify the namespace uri with the given 'URI'. If the namespace is not defined to the node with the given prefix, it will create a new namespace with the given prefix and uri. If the prefix is null, then it is treated as a default namespace.
Parameters:

node - The reference of the node for which the namespace definition is to be set.

prefix - The namespace prefix

uri - The namespace URI

Returns:

Returns 0 on success, -1 on failure.

Throws:
Throws - an IllegalArgumentException, if the uri is null or the prefix is empty String.

Example:
```
 
      int element = document.load("<element xmlns:ns=\"http://cordys.com/test\"/>".getBytes());
      Node.setNSDefinition(element,"ns","http://cordys.com/ns");
      // Now, the element node will look like
      //   <element xmlns:ns="http://cordys.com/ns"/>
      // If 'ns' is not defined to the element node, then it will create a new namespace definition.
 
 
```

setNSPrefix
```
public static int setNSPrefix(int node,
                              java.lang.String prefix)
```
Set the namespace prefix to the node. If the given prefix is not defined to the node or to its ancestor elements, it will throw the
```
 XMLException
 
```
If the namespace prefix is already set to the node, It will modify the namespace prefix with the given prefix value. If the namespace prefix is not set to the node, It will set the namespace prefix with the given prefix value. If the prefix is null, then it is treated as a default namespace.
Parameters:

node - The reference of the node forwhich the namespace definition is to be set.

prefix - The namespace prefix

Returns:

Returns 0 on success, -1 on failure.

Throws:
Throws - an IllegalArgumentException, if the prefix is empty String.

Example:
```
 
      int element = document.load("<element xmlns:ns=\"http://cordys.com/test\"/>".getBytes());
      Node.setNSPrefix(element,"ns");
      // Now, the element node will look like
      //   <ns:element xmlns:ns="http://cordys.com/ns"/>
 
 
```

setNSPrefixRecursive
```
public static int setNSPrefixRecursive(int node,
                                       java.lang.String oldPrefix,
                                       java.lang.String newPrefix)
```
Set the old namespace prefix to the new namespace prefix recursively to the given node and its children. If the prefix is null, then it is treated as a default namespace.
Parameters:

node - The reference of the node forwhich the namespace definition is to be set.

oldPrefix - The old namespace prefix of the node

newPrefix - The new namespace prefix of the node

Returns:

Returns 0 on success, -1 on failure.

Throws:

Throws - an XMLException, if the given oldPrefix or newPrefix is not defined to the node or to its ancestor elements
Throws - an IllegalArgumentException, if the oldPrefix or newPrefix is empty String.

Example:
```
 
      int element = document.load("<ns:element xmlns:nsNew=\"http://cordys.com/nsnew\" xmlns:ns=\"http://cordys.com/test\"/>".getBytes());
      Node.setNSPrefixRecursive(element,"ns", "nsNew");
      // Now, the element node will look like
      //   <nsNew:element xmlns:nsNew="http://cordys.com/nsnew" xmlns:ns="http://cordys.com/test"/>
 
 
```

getAttribute
```
public static java.lang.String getAttribute(int node,
                                            java.lang.String name)
```
Returns the value of the attribute for the specified attribute name of the given node, if the node is of type Element
Parameters:

node - The reference of the node

name - The name of the attribute

Returns:
The value of the attribute if the attribute available, otherwise it returns null.

Example:
```
 
 int element = document.load("<element att=\"attVal\"/>".getBytes());
 String value = Node.getAttribute(element, "att"); // returns 'attVal'
 
 
```

getAttributeNS
```
public static java.lang.String getAttributeNS(int node,
                                              java.lang.String name,
                                              java.lang.String uri)
```
Returns the value of the attribute for the specified attribute name which is bound with the given namespace URI of the given node, if the node is of type Element
Parameters:

node - The reference of the node

name - The name of the attribute

uri - The namespace URI of the attribute, The special value "*" matches all namespaces

Returns:
The value of the attribute if the attribute available, otherwise it returns null.

Example:
```
 
      int element = document.load("<element xmlns:ns=\"http://cordys.com/test\" ns:att=\"attVal\"/>".getBytes());
      String value = Node.getAttributeNS(element,"att", "http://cordys.com/test"); // returns 'attVal'
 
 
```

removeAttribute
```
public static int removeAttribute(int node,
                                  java.lang.String name)
```
Removes the attribute with the specified name in the node, and returns the result of this action (0 if succeeded).
Parameters:

node - The reference of the node

name - The name of the attribute to be removed

Returns:
Returns zero if the attribute is removed, a negative value if it fails to remove.

Example:
```
 
 int element = document.load("<element att=\"attVal\"/>".getBytes());
 int isDeleted = Node.removeAttribute(element, "att");
 //Now, the element node will look like
 //<element/>
 
 
```

removeAttributeNS

public static int removeAttributeNS(int node,
                                    java.lang.String name,
                                    java.lang.String URI)

Removes the attribute with the specified name & URI in the node, and returns the result of this action (0 if succeeded).

Parameters:

node - The reference of the node

name - The name of the attribute to be removed

URI - the namespace URI of the attribute to remove. The special value "*" matches all namespaces

Returns:

Returns zero if the attribute is removed, a negative value if it fails to remove.

Example:

 
 int element = document
                .load("<ns:element ns:att=\"attVal\" ns:att1=\"testing\" xmlns:ns=\"http://test.com\"/>"
                                .getBytes());
 int isDeleted = Node.removeAttributeNS(element, "att", "http://test.com/");
 // removing attribute using its local name
 int isAtt1Deleted = Node.removeAttributeNS(element, "att1", "*");

removeAttributesRecursive

public static int removeAttributesRecursive(int node,
                                            java.lang.String name1,
                                            java.lang.String name2,
                                            java.lang.String name3,
                                            java.lang.String name4)

Removes the attributes with the specified names recursively from the node and children, and returns the result of this action (0 if succeeded).

Parameters:

node - The reference of the node

name1 - The name of the attribute to be removed

name2 - The name of the attribute to be removed

name3 - The name of the attribute to be removed

name4 - The name of the attribute to be removed

Returns:

Returns zero if the attributes have removed successfully, a negative value if it fails to remove.

Example:

 
 Document oDocument = new Document();
 String xmlStr = "<root><table attr1=\"abc\" attr2=\"def\" attr3=\"ghi\" attr4=\"jkl\">xyz</table><chair/></root>";
 try {
        int result = oDocument.load(xmlStr.getBytes());
        Node.removeAttributesRecursive(result, "attr1", "attr2", "attr3", "attr4");
        assertEquals("<root><table>xyz</table><chair/></root>", Node.writeToString(
                        result, false));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNumAttributes

public static int getNumAttributes(int node)

Returns the number of attributes in the node, if it is of type element

Parameters:

node - The reference of the node

Returns:

The number of attributes available to the given node.

Example:

 
 Document oDocument = new Document();
 String xmlStr = "<oldelement/>";
 try {
        int result = 0;
        result = oDocument.load("<element attr1=\"xys\" attr2=\'abc\'></element>"
                        .getBytes());
        int ret = Node.getNumAttributes(result);
        assertEquals(2, ret);
 } catch (XMLException e) {
        e.printStackTrace();
 }

getAttributeName
```
public static java.lang.String getAttributeName(int node,
                                                int index)
```
Returns the name of the attribute with the specified index in the node
Parameters:

node - The reference of the node

index - The index of the attribute where the index starts from 1.

Returns:
Returns the name of the attribute at the given index if available, if there is no attribute at the given index it returns empty string otherwise it returns null.

Example:
```
 
 int element = document.load("<element att=\"attVal\"/>".getBytes());
 String attName = Node.getAttributeName(element, 1); // returns 'att'
 
 
```

getAttributeLocalName

public static java.lang.String getAttributeLocalName(int node,
                                                     int index)

Returns the local name of the attribute with the specified index in the node

Parameters:

node - The reference of the node

index - The index of the attribute where the index starts from 1.

Returns:

Returns the local name of the attribute at the given index if available, otherwise it returns null.

Example:

 
      int element = document.load("<element xmlns:ns=\"http://cordys.com/test\" ns:att=\"attVal\"/>".getBytes());
      String attName = Node.getAttributeLocalName(element,2); // returns 'att'

getAttributePrefix
```
public static java.lang.String getAttributePrefix(int node,
                                                  int index)
```
Returns the namespace prefix of the attribute with the specified index in the node
Parameters:

node - The reference of the node

index - The index of the attribute where the index starts from 1.

Returns:
Returns the namespace prefix of the atttirbute at the given index if available, otherwise it returns null.

Example:
```
 
      int element = document.load("<element xmlns:ns=\"http://cordys.com/test\" ns:att=\"attVal\"/>".getBytes());
      String attName = Node.getAttributePrefix(element,2); // returns 'ns'
 
 
```

getAttributeNamespaceURI
```
public static java.lang.String getAttributeNamespaceURI(int node,
                                                        int index)
```
Returns the namespace URI associated with the namespace prefix of the attribute with the specified index in the node
Parameters:

node - The reference of the node

index - The index of the attribute where the index starts from 1.

Returns:
Returns the namespace URI of the atttirbute at the given index if available, otherwise it returns null.

Example:
```
 
      int element = document.load("<element xmlns:ns=\"http://cordys.com/test\" ns:att=\"attVal\"/>".getBytes());
      String attName = Node.getAttributeNamespaceURI(element,2); // returns 'http://cordys.com/test'
 
 
```

getType

public static int getType(int node)

Returns the type of the node

Parameters:

node - The node reference

Returns:

Returns the integer value representing the type of the node.

Example:

 
      int element = document.load("<element xmlns:ns=\"http://cordys.com/test\" ns:att=\"attVal\"/>".getBytes());
      String attName = Node.getType(element); // returns 8 (of type node)

See Also:

NodeType

getCompoundType

public static int getCompoundType(int node)

Returns the compound type of the node

Parameters:

node - The node reference

Returns:

Returns the integer value representing the compound type of the node.

Example:

 
      int element = document.load("<element xmlns:ns=\"http://cordys.com/test\" ns:att=\"attVal\"/>".getBytes());
      String attName = Node.getCompoundType(element); // returns 0 (of type BASE)

See Also:

CompoundType

getDataType
```
public static int getDataType(int node)
```
Returns the datatype of the node for which the attribute dt is set
Parameters:

node - The element reference forwhich the data type is required.

Returns:
The integer value representing the datatype of the node. *

Example:
```
 
 int element = document.load("<element>xyz<child1/><child2/></element>"
                .getBytes());
 String attName = Node.getCompoundType(element); // returns 1 (of type STRING)
 
 
```
See Also:

DataType

getParent

public static int getParent(int node)

Returns the parent node reference of the given node reference

Parameters:

node - The node reference.

Returns:

The node reference of the parent. Returns zero if the parent is not available.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        result = Node.getFirstChild(result);
        result = Node.getParent(result);
        assertEquals("element", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getFirstChild

public static int getFirstChild(int node)

Returns the first child of the node.It can be either a data node or an element node.

Parameters:

node - The node reference.

Returns:

The node reference of the first child node of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        result = Node.getFirstChild(result);
        assertEquals("xyz", Node.getData(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getFirstChildElement

public static int getFirstChildElement(int node)

Returns the first child element of the node

Parameters:

node - The node reference.

Returns:

The node reference of the first child node of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        result = Node.getFirstChildElement(result);
        assertEquals("child1", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getLastChild

public static int getLastChild(int node)

Returns the last child of the node.It can be either a data node or an element node.

Parameters:

node - The node reference.

Returns:

The node reference of the last child node of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element><child1/><child2/></element>".getBytes());
        result = Node.getLastChild(result);
        assertEquals("child2", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getLastChildElement

public static int getLastChildElement(int node)

Returns the last child element of the node

Parameters:

node - The node reference.

Returns:

The node reference of the last child node of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/>xyz</element>"
                        .getBytes());
        result = Node.getLastChildElement(result);
        assertEquals("child2", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getPreviousSibling

public static int getPreviousSibling(int node)

Returns the previous (left) sibling of the node.It can be either a data node or an element node.

Parameters:

node - The node reference.

Returns:

The node reference for left sibling of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/>xyz</element>"
                        .getBytes());
        result = Node.getFirstChildElement(result);
        result = Node.getPreviousSibling(result);
        assertEquals("xyz", Node.getData(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getPreviousElement

public static int getPreviousElement(int node)

Returns the previous (left) sibling element of the node

Parameters:

node - The node reference.

Returns:

The node reference for left sibling of the given node.

Example:

 
 ocument oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/>xyz</element>"
                        .getBytes());
        result = Node.getLastChild(result);
        result = Node.getPreviousElement(result);
        assertEquals("child2", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNextSibling

public static int getNextSibling(int node)

Returns the next (right) sibling of the node.It can be either a data node or an element node.

Parameters:

node - The node reference.

Returns:

The node reference for right sibling of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/>xyz</element>"
                        .getBytes());
        result = Node.getFirstChildElement(result);
        result = Node.getNextSibling(result);
        assertEquals("child2", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNextElement

public static int getNextElement(int node)

Returns the next (right) sibling element of the node

Parameters:

node - The node reference.

Returns:

The node reference for right sibling of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        result = Node.getFirstChild(result);
        result = Node.getNextElement(result);
        assertEquals("child1", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNumChildren

public static int getNumChildren(int node)

Returns the number of children of the node.It counts both data nodes and element nodes.

Parameters:

node - The node reference

Returns:

The number of children elements of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        int num = Node.getNumChildren(result);
        assertEquals(3, num);
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNumChildElements

public static int getNumChildElements(int node)

Returns the number of child elements of the node

Parameters:

node - The node reference

Returns:

The number of children elements of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/>xyz</element>"
                        .getBytes());
        int num = Node.getNumChildElements(result);
        assertEquals(2, num);
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNumSiblings

public static int getNumSiblings(int node)

Returns the number of siblings of the node.It counts both data nodes and element nodes.

Parameters:

node - The node reference

Returns:

The number of siblings of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/>xyz</element>"
                        .getBytes());
        int num = Node.getNumSiblings(Node.getFirstChild(result));
        assertEquals(3, num);
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNumSiblingElements

public static int getNumSiblingElements(int node)

Returns the number of sibling elements of the node

Parameters:

node - The node reference

Returns:

The number of sibling elements of the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        int num = Node.getNumSiblingElements(Node.getFirstChild(result));
        assertEquals(2, num);
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNumPreviousSiblings

public static int getNumPreviousSiblings(int node)

Returns the number of siblings previous to (on the left of) the node including elements and text

Parameters:

node - The node reference

Returns:

The number of siblings which are previous to the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        int num = Node.getNumPreviousSiblings(Node.getLastChild(result));
        assertEquals(3, num);
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNumPreviousSiblingElements

public static int getNumPreviousSiblingElements(int node)

Returns the number of sibling elements previous to (on the left of) the node

Parameters:

node - The node reference

Returns:

The number of sibling elements which are previous to the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        int num = Node.getNumPreviousSiblingElements(Node.getLastChild(result));
        assertEquals(2, num);
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNumNextSiblings

public static int getNumNextSiblings(int node)

Returns the number of siblings next to (on the right of) the node including elements and text

Parameters:

node - The node reference

Returns:

The number of siblings which are next to the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        int num = Node.getNumNextSiblings(Node.getFirstChild(result));
        assertEquals(3, num);
 } catch (XMLException e) {
        e.printStackTrace();
 }

getNumNextSiblingElements

public static int getNumNextSiblingElements(int node)

Returns the number of sibling elements next to (on the right of) the node

Parameters:

node - The node reference

Returns:

The number of sibling elements which are next to the given node.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        int num = Node.getNumNextSiblingElements(Node.getFirstChild(result));
        assertEquals(2, num);
 } catch (XMLException e) {
        e.printStackTrace();
 }

write

public static byte[] write(int from,
                           int to,
                           int pretty)

Writes the given range of nodes to byte-array

Parameters:

from - The start element reference from which the write operation begins.

to - The end element reference where the write operation ends.

pretty - If this value is 1, it is written with indentation. If this value is 0, it is written without indentation.

Returns:

The byte array containing the given range of elements written.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element></element>".getBytes());
        byte[] obyteArr = Node.write(result, result, 0);
        assertEquals("<element/>", new String(obyteArr));
 } catch (XMLException e) {
        e.printStackTrace();
 }

writeWithNSInfo

public static byte[] writeWithNSInfo(int from,
                                     int to,
                                     int pretty)

Writes the given range of nodes to byte-array with namespace information(defined in ancestor node)

Parameters:

from - The start element reference from which the write operation begins.

to - The end element reference where the write operation ends.

pretty - If this value is 1, it is written with indentation. If this value is 0, it is written without indentation.

Returns:

The byte array containing the given range of elements written.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element xmlns:ns=\"http://cordys.com/test\">xyz<ns:child1/><child2/></element>"
                        .getBytes());
        result = Node.getFirstChild(result);
  byte[] obyteArr = Node.writeWithNSInfo(result, result, 0);
        assertEquals("<ns:child1 xmlns:ns=\"http://cordys.com/test\"/>", new String(obyteArr));
 } catch (XMLException e) {
        e.printStackTrace();
 }

write

public static byte[] write(int node,
                           boolean pretty)

Writes the contents of the node into the byte-array

Parameters:

node - The node that is to be written

pretty - If this value is true, it is written with indentation. If this value is false, it is written without indentation.

Returns:

The byte array containing the given node written to it.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element></element>".getBytes());
        byte[] obyteArr = Node.write(result, false);
        assertEquals("<element/>", new String(obyteArr));
 } catch (XMLException e) {
        e.printStackTrace();
 }

deflate
```
public static byte[] deflate(int node)
```
It compresses the content of the node.This method takes the data of the NOM node, and does not include the element name or attributes of the NOM node.
Parameters:

node - NOM node handle whose data is to be compressed. If the NOM node is of type Node.ELEMENT, then the data to be compressed will be taken from the content of element, and does not include element name or attributes. If the NOM node is of type Node.DATA, then the data to be compressed will be taken from the input data node till last right sibling (including element & data nodes).

Returns:

compressed byte array

See Also:
com.cordys.util.ZlibInflater} Example: public void testDeflate() { try { int root = doc.load("xml input".getBytes()); byte[] arr = Node.deflate(root); IInflater inflater = new ZlibInflater(); byte[] ret = inflater.inflate(arr); String deCompressed = new String(ret); assertEquals(Node.getData(root), deCompressed); } catch (XMLException e) { e.printStackTrace(); } }

writeToString

public static java.lang.String writeToString(int node,
                                             boolean pretty)

Writes the contents of the node into the string

Parameters:

node - The node that is to be written

pretty - If this value is true, it is written with indentation. If this value is false, it is written without indentation.

Returns:

The string containing the given node written to it.

Example:

 
 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element></element>".getBytes());
        String str = Node.writeToString(result, false);
        assertEquals("<element/>", str);
 } catch (XMLException e) {
        e.printStackTrace();
 }

writeToStringWithNSInfo

public static java.lang.String writeToStringWithNSInfo(int node,
                                                       boolean pretty)

Writes the contents of the node with namespace information(defined in ancestor node)into the string

Parameters:

node - The node that is to be written

pretty - If this value is true, it is written with indentation. If this value is false, it is written without indentation.

Returns:

The string containing the given node written to it.

Example:

 
 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element xmlns:ns=\"http://cordys.com/test\">xyz<ns:child1/><child2/></element>"
                        .getBytes());
        result = Node.getFirstChild(result);
        String str = Node.writeToStringWithNSInfo(result, false);
        assertEquals("<ns:child1 xmlns:ns=\"http://cordys.com/test\"/>", str);
 } catch (XMLException e) {
        e.printStackTrace();
 }

writeToFile
```
public static final void writeToFile(int from,
                                     int to,
                                     java.lang.String file,
                                     int pretty)
                              throws XMLException
```
Writes a range of nodes to a file. Always uses UTF-8 encoding to write xml.
Parameters:

from - The start element reference.

to - The end element reference.

file - The name of the file to write to (If path for the file is not specified then the file is written to the directory from where the java application is invoked i.e. if used in soap processor which is started as System process then the file is written to OS System directory i.e. C:\Windows\system32 in case of WindowsXP, etc.)

pretty - Indicates whether to write with indentation or normally and whether the xml header needs to be included or not. It can be created by Oring WRITE_PRETTY and WRITE_HEADER to indicate that both indentation and inclusion of xml header should take place

Throws:
XMLException - if the nodes could not be written to the file

Example:
```
 
 Document oDocument = new Document();
 try {
        int result = 0;
        String fileName = ".\\newFile.xml";
        result = oDocument.load("<element></element>".getBytes());
        Node.writeToFile(result, result, fileName, Node.WRITE_PRETTY
                        + Node.WRITE_HEADER);
 } catch (XMLException e) {
        e.printStackTrace();
 }
 
 
```

getFirstElement

public static int getFirstElement(int node)

Returns the first child of node which is of type element

Parameters:

node - The node reference to retrieve the first child element

Returns:

The reference to the first element node, or 0 if the node has no child element.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        result = Node.getFirstElement(result);
        assertEquals("child1", Node.getName(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getFirstDataNode

public static int getFirstDataNode(int node)

Returns the first child of node that is of type data

Parameters:

node - The node to retrieve the first data child from

Returns:

The reference to the first data node, or 0 if the node has no data child.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element>xyz<child1/><child2/></element>"
                        .getBytes());
        result = Node.getFirstDataNode(result);
        assertEquals("xyz", Node.getData(result));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getAttribute

public static java.lang.String getAttribute(int node,
                                            java.lang.String name,
                                            java.lang.String defaultValue)

Returns the value of the given attribute, or the default value if the attribute does not exist

Parameters:

node - The node reference from which the attribute value is to be retrieved

name - The name of the attribute

defaultValue - The default value that is to be returned if the attribute is not found.

Returns:

The attribute value if available, or the defaultValue if the attribute is not available.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element attr=\"abc\"></element>".getBytes());
        String str = Node.getAttribute(result, "attr", "default");
        assertEquals("abc", str);
        str = Node.getAttribute(result, "att", "default");
        assertEquals("default", str);
 } catch (XMLException e) {
        e.printStackTrace();
 }

getAttributeNS

public static java.lang.String getAttributeNS(int node,
                                              java.lang.String name,
                                              java.lang.String uri,
                                              java.lang.String defaultValue)

Returns the value of the given attribute which is bound with the give URI, or the default value if the attribute does not exist

Parameters:

node - The node reference from which the attribute value is to be retrieved

name - The name of the attribute

uri - The namespace URI of the attribute

defaultValue - The default value that is to be returned if the attribute is not found.

Returns:

The attribute value if available, or the defaultValue if the attribute is not available.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument
                        .load("<element xmlns:ns=\"http://cordys.com/test\" ns:attr=\"xyz\"></element>"
                                        .getBytes());
        String str = Node.getAttributeNS(result, "ns", null, "Default");
        assertEquals("Default", str);
        str = Node.getAttributeNS(result, "attr", "http://cordys.com/test",
                        "Default");
        assertEquals("xyz", str);
 
 } catch (XMLException e) {
        e.printStackTrace();
 }

getAttributeInt

public static int getAttributeInt(int node,
                                  java.lang.String name,
                                  int defaultValue)

Returns the value of the given attribute value as integer, or the default value if the attribute does not exist or is not an integer value.

Parameters:

node - The node reference from which the attribute value is to be retrieved

name - The name of the attribute

defaultValue - The default value that is to be returned if the attribute is not found or is not integer.

Returns:

The attribute value if available, or the defaultValue if the attribute is not available or is not integer.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element attr=\"50\"></element>".getBytes());
        int ret = Node.getAttributeInt(result, "attr2", -99);
        assertEquals(-99, ret);
        ret = Node.getAttributeInt(result, "attr", -99);
        assertEquals(50, ret);
 
 } catch (XMLException e) {
        e.printStackTrace();
 }

getElement

public static int getElement(int node,
                             java.lang.String tagName)

Returns a first child node with the given tag name.

Parameters:

node - The node reference

tagName - The tag name of the child element

Returns:

the node reference of the first child available with the given tag name. It returns 0 if the given tag name is not available.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element><child1/></element>".getBytes());
        int ret = Node.getElement(result, "child1");
        assertEquals("child1", Node.getName(ret));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getElementNS

public static int getElementNS(int node,
                               java.lang.String tagName,
                               java.lang.String uri)

Returns a child node, with the given name which is bound with the given URI or 0.

Parameters:

node - The element reference

tagName - The tag name of the element

uri - The namespace URI bywhich the element bound

Returns:

Returns the element with the given tag name which bound with the given namespace URI.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument
                        .load("<ns:element xmlns:ns=\"http://cordys.com/test\"><ns:child1/></ns:element>"
                                        .getBytes());
        int ret = Node.getElementNS(result, "child1", "http://cordys.com/test");
        assertEquals("ns:child1", Node.getName(ret));
 } catch (XMLException e) {
        e.printStackTrace();
 }

nameEquals

public static boolean nameEquals(int node,
                                 java.lang.String name)

Checks whether the name of the node is equal to the given 'name'.

Parameters:

node - the node reference.

name - the name of the node that is to be compared.

Returns:

true of the name is equal to the given value, otherwise it returns false.

Example:

 
 Document oDocument = new Document();
 try {
        int result = 0;
        result = oDocument.load("<element><child1/></element>".getBytes());
        assertEquals(true, Node.nameEquals(result, "element"));
 } catch (XMLException e) {
        e.printStackTrace();
 }

getDocument

public static Document getDocument(int node)

Returns a Document object to which the node belongs.

Parameters:

node - The node to retrieve the document from

Returns:

The Document object corresponding the the given node.

Example:

 
 Document oDocument = new Document();
 Document oDocument2;
 try {
        int result = 0;
        result = oDocument.load("<element><child1/></element>".getBytes());
        oDocument2 = Node.getDocument(result);
        assertEquals(true, oDocument2 == oDocument);
        assertEquals(true, oDocument2.equals(oDocument));
 } catch (XMLException e) {
        e.printStackTrace();
 }

createElementNS

@Deprecated
public static int createElementNS(java.lang.String name,
                                               java.lang.String content,
                                               int parent)

Deprecated. in C3, use createElementWithParentNS()

Creates a new element with parent namespace details and appends it to the children of the indicated parent.

Example:

 
  String xml =
 "<ns:root xmlns:ns="http://cordys.com/test/">
        <ns:employee> Cordys employee </ns:employee>
        <employee1>
                <test> Cordys employee </test>
        </employee1>
 </ns:root>";
 
        Document doc = new com.eibus.xml.nom.Document();
  int root = doc.load(xml.getBytes());
  int emp = Node.getElement(root, "employee1");
 
 // Creates an element which is child to root element as "<ns:employee2>emplyee2 data</ns:employee2>"
  Node.createElementNS("employee2","employee2 data", root); // parent element has namespace 'ns'
 
 // Creates an element which is child to employee1 element as "<employee3>emplyee3 data</employee3>"
  Node.createElementNS("employee3","employee3 data", emp); // parent element has no namespace

Parameters:: name - local name of new element; content - content/data of the new element; parent - handle of parent element. If 0 passed, then Exception will be thrown
Returns:: The reference of the created element

createElementWithParentNS

public static int createElementWithParentNS(java.lang.String name,
                                            java.lang.String content,
                                            int parent)

Creates a new element with parent namespace details and appends it to the children of the indicated parent.

Parameters:

name - local name of new element

content - content/data of the new element

parent - handle of parent element. If 0 passed, then Exception will be thrown

Returns:

The reference of the created element

Example:

 
  String xml =
 "<ns:root xmlns:ns="http://cordys.com/test/">
        <ns:employee> Cordys employee </ns:employee>
        <employee1>
                <test> Cordys employee </test>
        </employee1>
 </ns:root>";
 
        Document doc = new com.eibus.xml.nom.Document();
  int root = doc.load(xml.getBytes());
  int emp = Node.getElement(root, "employee1");
 
 // Creates an element which is child to root element as "<ns:employee2>emplyee2 data</ns:employee2>"
  Node.createElementWithParentNS("employee2","employee2 data", root); // parent element has namespace 'ns'
 
 // Creates an element which is child to employee1 element as "<employee3>emplyee3 data</employee3>"
  Node.createElementWithParentNS("employee3","employee3 data", emp); // parent element has no namespace

createElementNS
```
@Deprecated
public static int createElementNS(java.lang.String name,
                                               java.lang.String content,
                                               java.lang.String prefix,
                                               int parent)
```
Deprecated. in C3, use createElementNSWithPrefix()

Creates a new element with namespace prefix 'prefix' and appends it to the children of the indicated parent. An exception will be thrown if 'prefix' is not defined in any of the ancestors of new element.

Parameters:

name - local name of new element

prefix - prefix for new element

content - content/data of the new element

parent - handle of parent element. If 0 passed, then Exception will be thrown

Returns:

The reference of the created element

createElementNSWithPrefix

public static int createElementNSWithPrefix(java.lang.String name,
                                            java.lang.String content,
                                            java.lang.String prefix,
                                            int parent)

Creates a new element with namespace prefix 'prefix' and appends it to the children of the indicated parent. An exception will be thrown if 'prefix' is not defined in any of the ancestors of new element.

Parameters:

name - local name of new element

prefix - prefix for new element

content - content/data of the new element

parent - handle of parent element. If 0 passed, then Exception will be thrown

Returns:

The reference of the created element

Example:

 
  String xml =
 "<ns:root xmlns:ns="http://cordys.com/test/">
        <ns:employee> Cordys employee </ns:employee>
        <employee1>
                <test> Cordys employee </test>
        </employee1>
 </ns:root>";
 
        Document doc = new com.eibus.xml.nom.Document();
  int root = doc.load(xml.getBytes());
  int emp = Node.getElement(root, "employee1");
 
 // Creates an element which is child to root element as "<ns:employee2>emplyee2 data</ns:employee2>"
  Node.createElementNSWithPrefix("employee2","employee2 data", "ns", root);
 
 // Creates an element which is child to employee1 element as "<ns:employee3>emplyee3 data</ns:employee3>"
  Node.createElementNSWithPrefix("employee3","employee3 data", "ns", emp);

createElementNS

public static int createElementNS(java.lang.String name,
                                  java.lang.String content,
                                  java.lang.String prefix,
                                  java.lang.String namespaceURI,
                                  int parent)

Creates a new element with the given namespace details and appends it to the children of the indicated parent.

Parameters:

name - The tagname for the new element

content - content/data of the new element

prefix - 'prefix' for the new element, if the prefix is null then the created element will have a default namespace with the given namespaceURI.

namespaceURI - namespace URI of the 'prefix'

parent - handle of parent element. If 0 passed, then Exception will be thrown

Returns:

The reference of the created element

Example:

 
  String xml =
 "<ns:root xmlns:ns="http://cordys.com/test/">
        <ns:employee> Cordys employee </ns:employee>
        <employee1>
                <test> Cordys employee </test>
        </employee1>
 </ns:root>";
 
        Document doc = new com.eibus.xml.nom.Document();
  int root = doc.load(xml.getBytes());
 
 // Creates an element which is child to root element as "<prefix:employee2 xmlns:prefix="http://www.cordys.com/test/">emplyee2 data</prefix:employee2>"
  Node.createElementNS("employee2","employee2 data", "prefix", "http://www.cordys.com/test/", root);

createCDataElementNS
```
@Deprecated
public static int createCDataElementNS(java.lang.String name,
                                                    java.lang.String CDataContent,
                                                    int parent)
```
Deprecated. in C3, use createCDataElementWithParentNS()

Creates a new CDATA element with parent namespace details and appends it to the children of the indicated parent.

Parameters:

name - local name of new element

CDataContent - CDataContent/CData of the new element

parent - handle of parent element. If 0 passed, then Exception will be thrown

Returns:

The reference of the created element

createCDataElementWithParentNS

public static int createCDataElementWithParentNS(java.lang.String name,
                                                 java.lang.String CDataContent,
                                                 int parent)

Creates a new CDATA element with parent namespace details and appends it to the children of the indicated parent.

Parameters:

name - local name of new element

CDataContent - CDataContent/CData of the new element

parent - handle of parent element. If 0 passed, then Exception will be thrown

Returns:

The reference of the created element

Example:

 
  String xml =
 "<ns:root xmlns:ns="http://cordys.com/test/">
        <ns:employee> Cordys employee </ns:employee>
        <employee1>
                <test> Cordys employee </test>
        </employee1>
 </ns:root>";
 
        Document doc = new com.eibus.xml.nom.Document();
  int root = doc.load(xml.getBytes());
  int emp = Node.getElement(root, "employee1");
 
 // Creates an element which is child to root element as "<ns:employee2><![CDATA[employee2 data]]></ns:employee2>"
  Node.createCDataElementWithParentNS("employee2","employee2 data", root); // parent element has namespace 'ns'
 
 // Creates an element which is child to employee1 element as "<employee3><![CDATA[employee3 data]]></employee3>"
  Node.createCDataElementWithParentNS("employee3","employee3 data", emp); // parent element has no namespace

createCDataElementNS
```
@Deprecated
public static int createCDataElementNS(java.lang.String name,
                                                    java.lang.String CDataContent,
                                                    java.lang.String prefix,
                                                    int parent)
```
Deprecated. in C3, use createCDataElementNSWithPrefix()

Creates a new CDATA element with input 'prefix' and appends it to the children of the indicated parent. An exception will be thrown if 'prefix' is not defined in any of the ancestors of new element.

Parameters:

name - local name of new element

prefix - prefix for new element

CDataContent - CDataContent of the new element

parent - handle of parent element. If 0 passed, then Exception will be thrown

Returns:

The reference of the created element

createCDataElementNSWithPrefix

public static int createCDataElementNSWithPrefix(java.lang.String name,
                                                 java.lang.String CDataContent,
                                                 java.lang.String prefix,
                                                 int parent)

Creates a new CDATA element with input 'prefix' and appends it to the children of the indicated parent. An exception will be thrown if 'prefix' is not defined in any of the ancestors of new element.

Parameters:

name - local name of new element

prefix - prefix for new element

CDataContent - CDataContent of the new element

parent - handle of parent element. If 0 passed, then Exception will be thrown

Returns:

The reference of the created element

Example:

 
  String xml =
 "<ns:root xmlns:ns="http://cordys.com/test/">
        <ns:employee> Cordys employee </ns:employee>
        <employee1>
                <test> Cordys employee </test>
        </employee1>
 </ns:root>";
 
        Document doc = new com.eibus.xml.nom.Document();
  int root = doc.load(xml.getBytes());
  int emp = Node.getElement(root, "employee1");
 
 // Creates an element which is child to root element as "<ns:employee2><![CDATA[employee2 data]]></ns:employee2>"
  Node.createCDataElementNSWithPrefix("employee2","employee2 data", "ns", root); // parent element has namespace 'ns'
 
 // Creates an element which is child to employee1 element as "<ns:employee3><![CDATA[employee3 data]]></ns:employee3>"
  Node.createCDataElementNSWithPrefix("employee3","employee3 data", "ns", emp); // parent element has no namespace

createCDataElementNS

public static int createCDataElementNS(java.lang.String name,
                                       java.lang.String CDataContent,
                                       java.lang.String prefix,
                                       java.lang.String namespaceURI,
                                       int parent)

Creates a new CDATA element with input namespace details and appends it to the children of the indicated parent.

Parameters:

name - The tagname for the new element

CDataContent - CDataContent of the new element

prefix - 'prefix' for the new element, if the prefix is null then the created element will have a default namespace with the given namespaceURI.

namespaceURI - namespace URI of the 'prefix'

parent - handle of parent element. If 0 passed, then Exception will be thrown.

Returns:

The reference of the created element

Example:

 
  String xml =
 "<ns:root xmlns:ns="http://cordys.com/test/">
        <ns:employee> Cordys employee </ns:employee>
        <employee1>
                <test> Cordys employee </test>
        </employee1>
 </ns:root>";
 
        Document doc = new com.eibus.xml.nom.Document();
  int root = doc.load(xml.getBytes());
 
 // Creates an element which is child to root element as "<prefix:employee2 xmlns:prefix="http://www.cordys.com/test/"><![CDATA[employee2 data]]></prefix:employee2>"
  Node.createCDataElementNS("employee2","employee2 data", "prefix", "http://www.cordys.com/test/", root);

getDataBytesWithDefault
```
public static byte[] getDataBytesWithDefault(int node,
                                             byte[] defaultValue)
```
Returns the data of the node in byte array, if it is of type Text, otherwise collects all data of all children nodes and returns that. If there is no data in the node or its children, the defaultValue is returned.

Parameters:

node - Reference to Node from where data has to be retrived

defaultValue - Value to be returned if the given element tag is not available or the data to the element is not available

Returns:

Data in the node as byte array int root = doc.parseString("<root>data</root>"); byte[] node = Node.getDataBytesWithDefault(root, null); assertEquals("data", new String(node));

getDataBytesForElement
```
public static byte[] getDataBytesForElement(int node,
                                            java.lang.String tag,
                                            byte[] defaultValue)
```
Retrieves the data of the first child of node that has the specified tagname

Parameters:

node - Reference to Node

tag - Name of the tag, whose data has to be retrived

defaultValue - Value to be returned if the given element tag is not available or the data to the element is not available

Returns:

byte array containg the data int root = doc.parseString("<root><child>data</child></root>"); byte[] node = Node.getDataBytesForElement(root,"child",null); assertEquals("data"), new String(node);

getDataBytesForElementWithNS
```
public static byte[] getDataBytesForElementWithNS(int node,
                                                  java.lang.String tag,
                                                  java.lang.String uri,
                                                  byte[] defaultValue)
```
Retrieves the data of the first child of node that has the specified tagname and which is bound with the given namespace URI.

Parameters:

node - Reference to Node

tag - Name of the tag, whose data has to be retrived

uri - The namespace URI of the element

defaultValue - That is to be returned if the given element tag is not available or the data to the element is not available.

Returns:

The data of the given element. If the data is not available, defaultValue will be returned. int root = doc.parseString("<root><child>data1</child><child xmlns=\"https://www.cordys.com\">data</child></root>"); byte[] node = Node.getDataBytesForElementWithNS(root,"child","https://www.cordys.com",null); assertEquals("data", new String(node));

setDataBytes
```
public static void setDataBytes(int node,
                                byte[] data)
```
Sets the given data in the node

Parameters:

node - reference to Node

data - bytes in UTF-8 that has to be set as data in the referenced node String xml = "<root>SomeData</root>"; int root = doc.parseString(xml); Node.setDataBytes(Node.getFirstChild(root), "test1".getBytes("UTF-8")); String data = Node.getData(root); assertEquals("test1", data);

setDataBytesForElement
```
public static void setDataBytesForElement(int node,
                                          java.lang.String tag,
                                          byte[] data)
```
Rewrites the data children of the element 'node' to have a new element as last child with 'tag' as element name . If the tag name is not given, then it will set the data to the given element itself.

Parameters:

node - reference to Node

tag - Name of the node whose value has to be set

data - bytes in UTF-8 that has to be added String xml = "<root><test>testing data</test><test1>testing data</test1><test>testing data</test><test1>testing data</test1><test>testing data</test><test1>testing data</test1></root>"; int root = 0; root = doc.parseString(xml); Node.setDataBytesForElement(root, "test1", "test1".getBytes("UTF-8")); int node = Node.getNextSibling(Node.getFirstChild(root)); String data = Node.getData(node); assertEquals("test1", data); Node.delete(root);

setDataBytesForElementWithNS
```
public static void setDataBytesForElementWithNS(int node,
                                                java.lang.String tag,
                                                java.lang.String uri,
                                                byte[] data)
```
Rewrites the data children of the element 'node' to have a new element as last child with 'tag' as element name and binds with the given namespace URI. If the tag name is not given, then it will set the data to the given element itself. If the given URI is not defined, it will create a default namespace with the given URI.

Parameters:

node - reference to Node

tag - Name of the node whose value has to be set

uri - Namespace URI

data - bytes in UTF-8 that has to be added String xml = "<root xmlns='http://test.com'><test>testing data</test><test1>testing data</test1><test>testing data</test><test1>testing data</test1><test>testing data</test><test1>testing data</test1></root>"; int root = 0; root = doc.parseString(xml); Node.setDataBytesForElementWithNS(root,"test1","http://test.com","new data".getBytes()); int node = Node.getNextSibling(Node.getFirstChild(root)); String data = Node.getData(node); assertEquals("new data", data);

setCDataBytesForElement
```
public static void setCDataBytesForElement(int node,
                                           java.lang.String tag,
                                           byte[] data)
```
Finds a first level child element of 'node' by name 'tag' and replaces the CData section by the given 'data'. If 'tag' element has child elements, then all the children are removed and only 'data' in the CData section exists.

Parameters:

node - XML element from which the operation starts

tag - element to be operated, if empty, then 'node' will be operated

data - bytes in UTF-8 that has to be added String cdata = "<tag><tag1>i>10</tag1><tag2>i>10 && j< 50</tag2><tag3>\"this is a cdata text\"</tag3><tag4>'this is in single quotes'</tag4></root>"; Node.createCDataElement("cdatanode", cdata, root); Node.setCDataBytesForElement(root, "cdatanode", cdata.getBytes()); String data = Node.getDataElement(root, "cdatanode", ""); assertEquals(cdata, data);

Class Node

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

WRITE_NORMAL

WRITE_PRETTY

WRITE_HEADER

Method Detail

isValidNode

listCompare

getPrefix

getLocalName

getNamespaceURI

getRoot

rewriteTextElement

setDataElement

setDataElementNS

setCDataElement

createElement

createTextElement

createCDataElement

getDataElement

getDataElementNS

delete

delete

captureTaceInMap

unlink

unlink

insert

insert

add

add

append

append

insertInChildren

appendToChildren

appendToChildren

clone

duplicate

duplicateElement

duplicate

duplicateAndInsert

duplicateAndAdd

duplicateAndAppend

duplicateAndInsertInChildren

duplicateAndAppendToChildren

setName

getName

setData

getData

getDataWithDefault

getData

getDataOfFirstDataChild

setAttribute

setAttributeNS

setNSDefinition

setNSPrefix

setNSPrefixRecursive

getAttribute

getAttributeNS

removeAttribute

removeAttributeNS

removeAttributesRecursive

getNumAttributes

getAttributeName

getAttributeLocalName

getAttributePrefix

getAttributeNamespaceURI

getType

getCompoundType

getDataType

getParent

getFirstChild

getFirstChildElement

getLastChild

getLastChildElement

getPreviousSibling

getPreviousElement

getNextSibling