NotSerializableException

Question

I have a class that imports :
import com.sun.xml.tree.ElementNode.*;
in this class i use createElement function, getElementsByTagName it gives an exception as :
java.io.NotSerializableException: com.sun.xml.tree.ElementNode
The console output is:
java.io.NotSerializableException: com.sun.xml.tree.ElementNode
at java.io.ObjectOutputStream.outputObject(ObjectOutputStream.java:845)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:342)
at java.util.Hashtable.writeObject(Hashtable.java:738)
at java.lang.reflect.Method.invoke(Native Method)
at java.io.ObjectOutputStream.invokeObjectWriter(ObjectOutputStream.java:1585)
at java.io.ObjectOutputStream.outputObject(ObjectOutputStream.java:907)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:342)
at java.io.ObjectOutputStream.outputClassFields(ObjectOutputStream.java:1567)
at java.io.ObjectOutputStream.defaultWriteObject(ObjectOutputStream.java:453)
at java.io.ObjectOutputStream.outputObject(ObjectOutputStream.java:911)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:342)
at java.io.ObjectOutputStream.outputClassFields(ObjectOutputStream.java:1567)
at java.io.ObjectOutputStream.defaultWriteObject(ObjectOutputStream.java:453)
at java.io.ObjectOutputStream.outputObject(ObjectOutputStream.java:911)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:342)
at java.io.ObjectOutputStream.outputClassFields(ObjectOutputStream.java:1567)
at java.io.ObjectOutputStream.defaultWriteObject(ObjectOutputStream.java:453)
at java.io.ObjectOutputStream.outputObject(ObjectOutputStream.java:911)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:342)
at java.util.Hashtable.writeObject(Hashtable.java:738)
at java.lang.reflect.Method.invoke(Native Method)
at java.io.ObjectOutputStream.invokeObjectWriter(ObjectOutputStream.java:1585)
at java.io.ObjectOutputStream.outputObject(ObjectOutputStream.java:907)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:342)
at java.io.ObjectOutputStream.outputClassFields(ObjectOutputStream.java:1567)
at java.io.ObjectOutputStream.defaultWriteObject(ObjectOutputStream.java:453)
at java.io.ObjectOutputStream.outputObject(ObjectOutputStream.java:911)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:342)
at com.netscape.server.servlet.platformhttp.PlatformNASSession.putMemberValue(Unknown Source)
at com.netscape.server.servlet.platformhttp.PlatformNASSession.saveSession(Unknown Source)
at com.netscape.server.servlet.platformhttp.PlatformHttpServletRequest.saveSession(Unknown Source)
at com.netscape.server.servlet.servletrunner.ServletRunner.execute(Unknown Source)
at com.kivasoft.applogic.AppLogic.execute(Unknown Source)
at com.kivasoft.applogic.AppLogic.execute(Unknown Source)
at com.kivasoft.thread.ThreadBasic.run(Native Method)
at java.lang.Thread.run(Thread.java:479)
The class prg is :
package nncls;
import java.io.*;
import java.util.*;
import javax.xml.parsers.*;
import org.xml.sax.*;
import org.w3c.dom.*;
import com.sun.xml.tree.*;
import com.sun.xml.tree.ElementNode.*;
class ElementTest extends com.sun.xml.tree.ElementNode implements java.io.Serializable {
     public ElementTest(){};
public class DataCarrier implements java.io.Serializable
     XmlDocument gXmlDocument;
     Node gRootNode;
     int gReferenceIdCtr;
     Hashtable gReferenceTable;
     public DataCarrier() {
     public DataCarrier(String pObjectName){
               gXmlDocument = new XmlDocument();
               gReferenceTable = new Hashtable();
               Node eroot = gXmlDocument;
               gRootNode = (Node)gXmlDocument.createElement("OBJECT");
               eroot.appendChild(gRootNode);
               eroot = gRootNode;
               gRootNode = (Node)gXmlDocument.createElement("NAME");
               eroot.appendChild(gRootNode);
               Text textnode = gXmlDocument.createTextNode(pObjectName);
               gRootNode.appendChild(textnode);
               gRootNode = (Node)gXmlDocument.getDocumentElement();
     public String traverseRecord(String refid) {
          try {
          System.out.println("In traverse record");
          boolean found = false;
          Node s5treenode ;
          s5treenode = null;
          System.out.println("In traverse record b4 getelementsbytagname");
          //eTestNode=(Element)gRootNode;
          NodeList list = ((Element)gRootNode).getElementsByTagName("REFID");
          System.out.println("In traverse record list.getLength()" + list.getLength());
          for(int i = 0;i < list.getLength();i++)
               System.out.println("in for loop of traverseRecord list.item(i) :" + list.item(i));
               s5treenode =list.item(i);
               String str5 = getValue(s5treenode);
               if(str5.equalsIgnoreCase(refid)) {
                    s5treenode = list.item(i);
                    found = true;
                    break;
          System.out.println("----------------------------");
          System.out.println("found?? :" + found);
          if(found)
               Node parentnode = (s5treenode.getParentNode()).getParentNode();
               Node namenode = findFirst(parentnode,"NAME");
               System.out.println("name node value :" + namenode);
               if(namenode != null)
                    Node testNode=(Node)s5treenode.getParentNode();
                    System.out.println("b4 putting in gref hastable" + s5treenode.getParentNode());
                    gReferenceTable.put(getValue(namenode),testNode);
                    System.out.println("aft putting");
                    return getValue(namenode);
               else
                    return "";
          return "";
     }catch(Exception e) {
          System.out.println(" in traverseRecord: " + e);
          return "";
     public Node findFirst(Node node,String name)     {
          try {
          System.out.println("in findFirst the value of node: " + node);
          if(node == null) {
               return null;
          Node s5treenode = node.getFirstChild();
          System.out.println("in find first the value of s5treenode:" + s5treenode);
          while(s5treenode != null) {
               if(s5treenode.getNodeName().equalsIgnoreCase(name)) {
                    System.out.println("the return value of s5treenode:"+ s5treenode);
                    return s5treenode;
               s5treenode = s5treenode.getNextSibling();
          System.out.println("-------------------------------------------");
          System.out.println("returning null in find first");
          return null;
     } catch(Exception e) {
          System.out.println("Exception in findFirst" + e);
          return null;
     public Node findNext(Node node,String name) {
          try{
          if(node == null) {
               return null;
          Node s5treenode = node.getNextSibling();
          while(s5treenode != null) {
               if(s5treenode.getNodeName().equalsIgnoreCase(name)) {
                    return s5treenode;
               s5treenode = s5treenode.getNextSibling();
          return null;
     } catch(Exception e) {
          System.out.println("Exception in findNext" + e);
          return null;
public Node findPrevious(Node node,String name) {
          try {
          if(node == null) {
               return null;
          Node s5treenode = null;
          s5treenode = node.getPreviousSibling();
          while(s5treenode != null) {
               if(s5treenode.getNodeName().equalsIgnoreCase(name)) {
                    return s5treenode;
               s5treenode = s5treenode.getPreviousSibling();
          return null;
     } catch(Exception e) {
          System.out.println("Exception in findPrevious" + e);
          return null;
     public String getValue(Node tempnode) {
          try {
          System.out.println("In get value");
          System.out.println("the val of tempnode.getFirstChild() in getValue : "+ tempnode.getFirstChild());
               System.out.println("has child nodes!!!!!!!!!!!!!!!!!!!!!!");
               Node child = tempnode.getFirstChild();
               System.out.println("after associating to child" + child);
               if((child != null) && (child.getNodeType() == Node.TEXT_NODE)) {
                         System.out.println(" the val of ((Text)child).getData(): " + ((Text)child).getData());
                         System.out.println("at the end of getValue");
                         return ((Text)child).getData();
               else {
                    System.out.println("in else the value of return value is empty");
                    return "";
          } catch(Exception e) {
               System.out.println("Exception in getValue" + e);
               return "";
     public void setValue(Node tempnode,String value) {
          try {
          if(value == null)
               value = "";
          value = value.trim();
          System.out.println(tempnode + "In setData function");
          System.out.println("The child is in setValue function: " + tempnode.getFirstChild());
          Node child = tempnode.getFirstChild();
          System.out.println("the node type in setData is: " + child);
          if((child != null) && (child.getNodeType() == Node.TEXT_NODE)) {
                    ((Text)child).setData(value);
          else
               Text textnode = gXmlDocument.createTextNode(value);
               tempnode.appendChild(textnode);
               System.out.println("At teh end of setValue before return");
               return;
          System.out.println("At teh end of setValue");
     } catch(Exception e) {
          System.out.println("Exception in setVALUE" + e);
          return;
     public String getObjectName()
          try{
          Node lObject = (Node)gReferenceTable.get("OBJECT");
          Node lNameNode = findFirst(lObject,"NAME");
          if(lNameNode != null)
               return getValue(lNameNode);
          else
               return "";
          }catch(Exception e) {
               System.out.println("Exception in getObjectName" + e);
               return "";
     public void firstObject()
          try{
          Node testNode=(Node)gRootNode;
          gReferenceTable.put("OBJECT",testNode);
          } catch(Exception e) {
               System.out.println("Exception in firstObject" + e);
     public boolean nextObject()
          try {
          Node lObject = (Node)gReferenceTable.get("OBJECT");
          lObject = findNext(lObject,"OBJECT");
          if(lObject != null)
               gReferenceTable.put("OBJECT",lObject);
               return true;
          else
               return false;
          }catch(Exception e) {
               System.out.println("Exception in nextobject" + e);
               return false;
     public void save()
          try {
               FileWriter files = new FileWriter("c:\\save.xml");
               gXmlDocument.write(files);
          } catch(Exception e) {
               System.out.println("In exception of save");
               e.printStackTrace();}
     public String getRecordOperation(String pType)
          try {
          System.out.println("In getrecordOperation ");
          Node recordnode = (Node)gReferenceTable.get(pType);
          Node performnode = findFirst(recordnode,"PERFORM");
          if(performnode != null)
               return getValue(performnode);
          return "";
          }catch(Exception e) {
               System.out.println("Exception in getRecordOperation" + e);
               return "";
     public void setRecordOperation(String pType,String pOperation)
          try {
          Node recordnode = (Node)gReferenceTable.get(pType);
          Node performnode = (Node)findFirst(recordnode,"PERFORM");
          if(performnode != null)
               setValue(performnode,pOperation);
          return;
          }catch(Exception e) {
               System.out.println("Exception in setRecordOperation" + e);
     public void InsertRoot(String type,String perform)
          try {
          Node child = (Node)gXmlDocument.createElement("RECORD");
          Node parent = gXmlDocument.getDocumentElement();
          System.out.println("in insert root");
          parent.appendChild(child);
          System.out.println("b4 putting in hashtable of insert root");
          gReferenceTable.put(type,child);
          System.out.println("aft putting in hashtable of insert root");
          Node childrecord;
          childrecord = (Node)gXmlDocument.createElement("PERFORM");
          child.appendChild(childrecord);
          System.out.println(childrecord + "append chile done" + childrecord.getNodeValue());
          setValue(childrecord,perform);
          childrecord = (Node)gXmlDocument.createElement("REFID");
          child.appendChild(childrecord);
          gReferenceIdCtr = gReferenceIdCtr + 1;
          String value = Integer.toString(gReferenceIdCtr);
          setValue(childrecord,value);
          System.out.println("At teh end of insrert root");
          }catch (Exception e) {
               System.out.println("Exception in InsertRoot" + e);
     private Node getDetail(Node parent,String type)
          try {
          NodeList list = ((Element)parent).getElementsByTagName("DETAIL");
          if(list.getLength() > 0)
               for(int i =0;i<list.getLength();i++)
                    Node detailnode = list.item(i);
                    Node namenode = detailnode.getFirstChild();
                    if(getValue(namenode).equalsIgnoreCase(type))
                         return detailnode;
          Node detailnode = (Node)gXmlDocument.createElement("DETAIL");
          parent.appendChild(detailnode);
          Node namenode = (Node)gXmlDocument.createElement("NAME");
          detailnode.appendChild(namenode);
          Node textnode = gXmlDocument.createTextNode(type);
          namenode.appendChild(textnode);
          return detailnode;
          } catch (Exception e) {
               System.out.println("Exception in getDetail" + e);
               return null;
     public void InsertChild(String parenttype,String type,String perform)
          try {
          Node parent = (Node)gReferenceTable.get(parenttype);
          Node detailnode = getDetail(parent,type);
          Node child = (Node)gXmlDocument.createElement("RECORD");
          detailnode.appendChild(child);
          gReferenceTable.put(type,child);
          Node childrecord;
          childrecord = (Node)gXmlDocument.createElement("PERFORM");
          child.appendChild(childrecord);
          if(perform.equals(""))
          else
               setValue(childrecord,perform);
          childrecord = (Node)gXmlDocument.createElement("REFID");
          child.appendChild(childrecord);
          gReferenceIdCtr = gReferenceIdCtr + 1;
          String value = Integer.toString(gReferenceIdCtr);
          setValue(childrecord,value);
          } catch(Exception e) {
               System.out.println("Exception in InsertChild" + e);
     public void AddField(String type,String fieldname,String fieldvalue)
          try {
          Node fieldnode;
          Node childnode;
          System.out.println("in addfield b4 parentnode");
          Node parent = (Node)gReferenceTable.get(type);
          System.out.println("aft get");
          fieldnode = (Node)gXmlDocument.createElement("FIELD");
          System.out.println("aft creating fieldnode");
          parent.appendChild(fieldnode);
          System.out.println("aft appendchild of fiel node");
          childnode = (Node)gXmlDocument.createElement("NAME");
          fieldnode.appendChild(childnode);
          setValue(childnode,fieldname);
          childnode = (Node)gXmlDocument.createElement("VALUE");
          fieldnode.appendChild(childnode);
          setValue(childnode,fieldvalue);
          //code changed by bala as on 13-08-2001
          childnode = (Node)gXmlDocument.createElement("OLDVALUE");
          fieldnode.appendChild(childnode);
          System.out.println("Allappend child done in addfield now calling setval");
          setValue(childnode,fieldvalue);
          //end of code changed by bala as on 13-08-2001
          } catch(Exception e) {
               System.out.println("Exception in AddField" + e);
     public String getField(String type,String fieldname)
          try {
          System.out.println( "In getField");
          Node recordnode = (Node)gReferenceTable.get(type);
          System.out.println( "after reference table in getField");
          Node fieldnode = findFirst(recordnode,"FIELD");
          System.out.println( "the value of fieldNode in getField :"+ fieldnode);
          while(fieldnode != null)
               System.out.println( "in getField the field type is:" + type + " fieldname : "+ fieldname);
               if((getValue((Node)findFirst((Node)fieldnode,"NAME"))).equalsIgnoreCase(fieldname)) {
                    System.out.println("-------------------------------------------");
                    System.out.println("in getfield b4 second time calling getValue:" + fieldnode);
                    return getValue((Node)findFirst((Node)fieldnode,"VALUE"));
               fieldnode = findNext(fieldnode,"FIELD");
          return "";
          } catch(Exception e) {
               System.out.println("Exception in getField" + e);
               return "";
     public void setField(String type,String fieldname,String fieldvalue)
          try {
               Node recordnode = (Node)gReferenceTable.get(type);
               Node fieldnode = findFirst(recordnode,"FIELD");
               boolean lFieldSet = false;
               while(fieldnode != null)
                    if((getValue(findFirst(fieldnode,"NAME"))).equalsIgnoreCase(fieldname))
                         lFieldSet = true;
                         setValue(findFirst(fieldnode,"VALUE"),fieldvalue);
                    fieldnode = findNext(fieldnode,"FIELD");
               if(!lFieldSet)
                    AddField(type,fieldname,fieldvalue);
          } catch(Exception e) {
               System.out.println("Exception in setField" + e);
     public boolean firstRecord()
          try {
          Node namenode = findFirst((Node)gRootNode,"NAME");
          Node recordnode = findNext(namenode,"RECORD");
          if(recordnode != null)
               gReferenceTable.put(getValue(namenode),recordnode);
               return true;
          return false;
     } catch(Exception e) {
          System.out.println("Exception in firstRecord" + e);
          return false;
     public boolean nextRecord(String type)
          try {
          Node recordnode = (Node)gReferenceTable.get(type);
          Node nextrecordnode = findNext(recordnode,"RECORD");
          if(nextrecordnode != null)
               gReferenceTable.put(type,nextrecordnode);
               return true;
          return false;
          } catch(Exception e) {
               System.out.println("Exception in nextRecord" + e);
               return false;
public boolean previousRecord(String type)
          try {
          Node recordnode = (Node)gReferenceTable.get(type);
          Node nextrecordnode = findPrevious(recordnode,"RECORD");
          if(nextrecordnode != null)
               gReferenceTable.put(type,nextrecordnode);
               return true;
          return false;
          }catch(Exception e) {
               System.out.println("Exception in previousRecord" + e);
               return false;
     public boolean firstChildRecord(String parenttype,String childtype)
          try
               Node parentrecordnode = (Node)gReferenceTable.get(parenttype);
               Node detailnode = (Node)findFirst(parentrecordnode,"DETAIL");
                         if(detailnode == null)
                              gReferenceTable.remove(childtype);
                              return false;
               while(detailnode != null)
                    Node namenode = detailnode.getFirstChild();
                    if(getValue(namenode).equalsIgnoreCase(childtype))
                         Node recordnode = (Node)findNext(namenode,"RECORD");
                         if(recordnode != null)
                              gReferenceTable.put(childtype,recordnode);
                              return true;
                    detailnode = findNext(detailnode,"DETAIL");
               return false;
          catch(Exception e)
               System.out.println(" in catch of firstChildRecord");
               e.printStackTrace();
               return false;
     public String getRootReferenceId()
          try {
          Node lRecordNode = findFirst((Node)gRootNode,"RECORD");
          if(lRecordNode == null)
               return "0";
          Node lReferenceIdNode = findFirst(lRecordNode,"REFID");
          return getValue(lReferenceIdNode);
          } catch(Exception e) {
               System.out.println("Exception in getRootReferenceId" + e);
               return "0";
     public String getReferenceId(String pType)
          try {
          System.out.println("In getReferenceId ");
          Node lRecordNode = (Node)gReferenceTable.get(pType);
          if(lRecordNode == null)
               return "0";
          System.out.println("b4 findFirst in getReference id");
          Node lReferenceIdNode = findFirst(lRecordNode,"REFID");
          System.out.println("after findfirst");
          return getValue(lReferenceIdNode);
          } catch(Exception e) {
               System.out.println("Exception in getReferenceId" + e);
               return "0";
     public boolean nextRecordNode(String pType,String pFilter)
          try {
          String lFilter = "";
          if(pFilter.equalsIgnoreCase("selected"))
               lFilter = "Y";
          Node lRecordNode = (Node)gReferenceTable.get(pType);
          Node lNextRecordNode = findNext(lRecordNode,"RECORD");
          if(lNextRecordNode != null)
               if(lFilter.equals(""))
                    gReferenceTable.put(pType,lNextRecordNode);
                    return true;
               else
                    Node lFieldNode = null;
                    Node lNameNode = null;
                    String lName = "",lValue = "";
                    Node lValueNode = null;
                    while(lNextRecordNode != null)
                         lFieldNode = findFirst(lNextRecordNode,"FIELD");
                         while(lFieldNode != null)
                              lNameNode = findFirst(lFieldNode,"NAME");
                              lName = getValue(lNameNode);
                              if(lName.equalsIgnoreCase("selected"))
                                   lValueNode = findNext(lNameNode,"VALUE");
                                   lValue = getValue(lValueNode);
                                   if(lValue.equalsIgnoreCase(lFilter))
                                        gReferenceTable.put(pType,lNextRecordNode);
                                        return true;
                              lFieldNode = findNext(lFieldNode,"FIELD");
                         lNextRecordNode = findNext(lNextRecordNode,"RECORD");
          else
               return false;
          return false;
          } catch(Exception e) {
               System.out.println("Exception in nextRecordNode" + e);
               return false;
     public void setErrorStatus(String pType,String pErrorCode,String pErrorDescription)
          try {
          Node lRecordNode = (Node)gReferenceTable.get(pType);
          if(lRecordNode != null)
               Node lStatusNode = findFirst(lRecordNode,"STATUS");
               if(lStatusNode == null)
                    lStatusNode = (Node)gXmlDocument.createElement("STATUS");
                    lRecordNode.appendChild(lStatusNode);
                    Node lErrorCodeNode = (Node)gXmlDocument.createElement("ERRORCODE");
                    lStatusNode.appendChild(lErrorCodeNode);
                    Node lErrorDescription = (Node)gXmlDocument.createElement("ERRORDESCRIPTION");
                    lStatusNode.appendChild(lErrorDescription);
               setValue(findFirst(lStatusNode,"ERRORCODE"),pErrorCode);
               setValue(findFirst(lStatusNode,"ERRORDESCRIPTION"),pErrorDescription);
          } catch(Exception e) {
               System.out.println("Exception in setErrorStatus" + e);
     public String getErrorStatusCode(String pType)
          try {
          Node lRecordNode = (Node)gReferenceTable.get(pType);
          if(lRecordNode != null)
               Node lStatusNode = findFirst(lRecordNode,"STATUS");
               if(lStatusNode != null)
                    return getValue(findFirst(lStatusNode,"ERRORCODE"));
          return "";
          } catch(Exception e) {
               System.out.println("Exception in getErrorStatusCode" + e);
               return "";
     public String getErrorStatusDescription(String pType)
          try{
          Node lRecordNode = (Node)gReferenceTable.get(pType);
          if(lRecordNode != null)
               Node lStatusNode = findFirst(lRecordNode,"STATUS");
               if(lStatusNode != null)
                    return getValue(findFirst(lStatusNode,"ERRORDESCRIPTION"));
          return "";
          } catch(Exception e) {
               System.out.println("Exception in getErrorStatusDescription" + e);
               return "";
     public String getNextReferenceId(String pType)
          try {
          Node lRecordNode = (Node)gReferenceTable.get(pType);
          if(lRecordNode != null)
               Node lNextRecordNode = findNext(lRecordNode,"RECORD");
               if(lNextRecordNode != null)
                    Node lReferenceIdNode = findFirst(lRecordNode,"REFID");
                    return getValue(lReferenceIdNode);
          return "";
     } catch(Exception e) {
          System.out.println("Exception in getNextReferenceId" + e);
          return "";
     public String getDCCurrentPositions()
          try {
          String lPositions = "",lDelimeter = ";";
          String lKey ="";
          Enumeration lKeysEnum = gReferenceTable.keys();
          Node lRecordNode = null;
          Node lReferenceIdNode = null;
          while(lKeysEnum.hasMoreElements())
               lKey = (String)lKeysEnum.nextElement();
               lRecordNode = (Node)gReferenceTable.get(lKey);
               lReferenceIdNode = findFirst(lRecordNode,"REFID");
               lPositions = lPositions+lKey+lDelimeter+getValue(lReferenceIdNode)+lDelimeter;
          return lPositions;
          } catch(Exception e) {
               System.out.println("Exception in getDCCurrentPositions" + e);
               return "";
     public void setDCCurrentPositions(String pRecordType)
          try {
          Node lNameNode = null;
          Node lRecordNode = (Node)gReferenceTable.get(pRecordType);
          Node lDetailNode = findFirst(lRecordNode,"DETAIL");
          while(lDetailNode != null)
               lNameNode = findFirst(lDetailNode,"NAME");
               lRecordNode = (Node)findFirst(lDetailNode,"RECORD");
               gReferenceTable.put(getValue(lNameNode),lRecordNode);
               setDCCurrentPositions(getValue(lNameNode));
               lDetailNode = findNext(lDetailNode,"DETAIL");
          } catch(Exception e) {
               System.out.println("Exception in getDCCurrentPositions" + e);
public void setListPositions(String pRecordType,String pReferenceId,int pCount)
               try {
int lCounter = 1;
String lStartingReferenceId = getReferenceId(pRecordType);
if(lStartingReferenceId.equals(pReferenceId))
                    return;
String lReferenceId = "";
boolean lExist = nextRecord(pRecordType);
while(lExist)
lCounter ++;
lReferenceId = getReferenceId(pRecordType);
if(lReferenceId.equals(pReferenceId))
                         if(lCounter > pCount)
                              lStartingReferenceId = lReferenceId;
pRecordType = traverseRecord(lStartingReferenceId);
return;
if(lCounter > pCount)
lStartingReferenceId = lReferenceId;
lCounter = 1;
lExist = nextRecord(pRecordType);
               } catch(Exception e) {
                    System.out.println("Exception in setListPositions" + e);
public String getParentReferenceId(String pRefernceId)
String lParentReferenceId = "";
try
String lChildType = traverseRecord(pRefernceId);
if(lChildType.length() > 0)
Node lChildRecordNode = (Node)gReferenceTable.get(lChildType);
Node lDetailNode = lChildRecordNode.getParentNode();
Node lRecordNode = lDetailNode.getParentNode();
Node lReferenceIdNode = findFirst(lRecordNode,"REFID");
lParentReferenceId = getValue(lReferenceIdNode);
return lParentReferenceId;
catch(Exception e)
                    System.out.println("Exception in getParentReferenceId" + e);
return lParentReferenceId;
          //new function added by balamb on 20-07-2001
          public void deleteNode(String pReferenceId)
               This function is supposed to find the record of the passed
               referenceid. If found, then store it. Check whether it has
               a previos record.if the prev record is present, make that
               as the current referred node. else check whether there is
               next record. if the next record is present,make that
               as the current referred node.*/
               try {
               String lsRecordType = traverseRecord(pReferenceId);
               if(lsRecordType.length() > 0)
                    Node lToBeDeletedNode = (Node)gReferenceTable.get(lsRecordType);
                    if(lToBeDeletedNode != null)
                         Node lToBeCurrentNode = (Node)findPrevious(lToBeDeletedNode,"RECORD");
                         if(lToBeCurrentNode != null)
                              //prev node is there. make it as current node
                              gReferenceTable.put(lsRecordType,lToBeCurrentNode);
                         else
                              //prev node is not there. check for next node
                              lToBeCurrentNode = (Node)findNext(lToBeDeletedNode,"RECORD");
                              if(lToBeCurrentNode != null)
                                   //next node is there. make it as current node
                                   gReferenceTable.put(lsRecordType,lToBeCurrentNode);
                              else
                                   gReferenceTable.remove(lsRecordType);
                         //delete the node
                         Node lParentNode = lToBeDeletedNode.getParentNode();
                         lToBeDeletedNode = lParentNode.removeChild(lToBeDeletedNode);
               } catch(Exception e) {
                    System.out.println("Exception in deleteNode" + e);
          //code changed by bala as on 13-08-2001
          public String getOldValue(String type,String fieldname)
               try {
               Node recordnode = (Node)gReferenceTable.get(type);
               Node fieldnode = findFirst(recordnode,"FIELD");
               while(fieldnode != null)
                    if((getValue(findFirst(fieldnode,"NAME"))).equalsIgnoreCase(fieldname))
                         return getValue(findFirst(fieldnode,"OLDVALUE"));
                    fieldnode = findNext(fieldnode,"FIELD");
               return "";
               } catch(Exception e) {
                    System.out.println("Exception in getOldValue" + e);
                    return "";
          //end of code changed by bala as on 13-08-2001
          public void removeAllDeletedNodes()
               try
                    String lsNodeValue;
                    NodeList lRecordNodes;
                    Node lPerformNode,lParentNode,lDetailNode,lPositionNode,lNameNode;
                    lRecordNodes = ((Element)gRootNode).getElementsByTagName("RECORD");
                    int lCtr = 0;
                    System.out.println("length of list is " + lRecordNodes.getLength());
                    if(lRecordNodes.getLength() > 0)
                         for(lCtr = 0; lCtr <= lRecordNodes.getLength() - 1;lCtr ++)
                              lPerformNode = findFirst(lRecordNodes.item(lCtr), "PERFORM");
                              System.out.println("perform node is " + lPerformNode);
                              if(lPerformNode != null)
                                   System.out.println("perform node is not nothing");
                                   lsNodeValue = "";
                                   lsNodeValue = getValue(lPerformNode);
                                   System.out.println("ls node val bef check is " + lsNodeValue);
                                   if(lsNodeValue.equalsIgnoreCase("DELETE"))
                                        System.out.println("lrec node inide del check is " + lRecordNodes.item(lCtr));
                                        lDetailNode = lRecordNodes.item(lCtr).getParentNode();
                                        lNameNode = findFirst(lDetailNode,"NAME");
                                        if((Node)gReferenceTable.get(getValue(lNameNode))==lRecordNodes.item(lCtr))
                                             System.out.println("position table has this node");
                                             lPositionNode = (Node)findPrevious(lRecordNodes.item(lCtr), "RECORD");
                                             if(lPositionNode == null)
                                                  // The Node is the first record under the
                                                  // detail. Position will be set to next
                                                  // record, if it is available
                                                  System.out.println("previous node is nothing");
                                                  lPositionNode = (Node)findNext(lRecordNodes.item(lCtr), "RECORD");
                                                  if(lPositionNode == null)
                                                       System.out.println("next node is also null");
                                                       gReferenceTable.remove(getValue(lNameNode));
                                                       System.out.println("af removing from ref id table");
                                                       Node lDetailParentNode;
                                                       lDetailParentNode = lDetailNode.getParentNode();
                                                       System.out.println("ldetail parentnode " + lDetailParentNode);
                                                       lDetailNode.removeChild(lRecordNodes.item(lCtr));
                                                       lDetailParentNode.removeChild(lDetailNode);
                                                       lCtr = lCtr - 1;
                                                       System.out.println("af removing the child node");
                                                       System.out.println("len of list af del child node " + lRecordNodes.getLength());
                                                  else
                                                       System.out.println("next node i

Answer 1

I don't think ElementNode is serializable.