D:\NewZebra\JavaApplications\DesignPatternsProject\src\structural_patterns\composite_tree\CompositeNodeServices.java
  1 /*
  2  * CompositeNodeServices.java
  3  *
  4  */
  5 
  6 package structural_patterns.composite_tree;
  7 
  8 /**
  9  *
 10  * @author Sam Eldin
 11  */
 12 
 13 import java.io.*;
 14 import java.text.*;
 15 import java.util.*;
 16 
 17 abstract public class CompositeNodeServices {
 18     
 19     /** Creates a new instance of CompositeNodeServices */
 20     public CompositeNodeServices() {
 21     }
 22     /*
 23      *
 24      */
 25     abstract public CompositeNode PollingTree();
 26     /*
 27      *
 28      */
 29     public CompositeNode  addNode(CompositeNode parentNode, CompositeUserObject passedCompositeUserObject)
 30     {
 31         CompositeNode  localCompositeNodeHandle = new CompositeNode(passedCompositeUserObject);
 32         if(parentNode != null)
 33             parentNode.add(localCompositeNodeHandle);
 34         // a node can have anull parent
 35         localCompositeNodeHandle.setParent(parentNode);
 36         return (localCompositeNodeHandle);
 37     }
 38     /*
 39      *
 40      */
 41     public CompositeNode  addNode(CompositeNode     parentNode, 
 42                                     String          passedNodeName,
 43                                     boolean         passedProcessedFlag,
 44                                     long            passedUserObjectID)
 45     {
 46         CompositeUserObject compositeUserObjectHandle = new CompositeUserObject();
 47         compositeUserObjectHandle.setNodeName(passedNodeName);
 48         compositeUserObjectHandle.setProcessedFlag(passedProcessedFlag);
 49         compositeUserObjectHandle.setUserObjectID(passedUserObjectID);
 50         CompositeNode  localCompositeNodeHandle = new CompositeNode(compositeUserObjectHandle);
 51         if(parentNode != null)
 52             parentNode.add(localCompositeNodeHandle);
 53         // a node can have anull parent
 54         localCompositeNodeHandle.setParent(parentNode);
 55         return (localCompositeNodeHandle);
 56     }
 57     /*
 58      *
 59      */
 60     public void pollRootNode(){
 61         
 62         if(null == CompositeNodeBase.ROOT){
 63             CompositeUserObject compositeUserObjectHandle = new CompositeUserObject();
 64             compositeUserObjectHandle.setNodeName(CompositeNodeBase.ROOT_NODE_NAME);
 65             compositeUserObjectHandle.setProcessedFlag(false);
 66             compositeUserObjectHandle.setUserObjectID(CompositeNodeBase.ROOT_NODE_ID);
 67             CompositeNodeBase.ROOT = new CompositeNode(compositeUserObjectHandle);
 68         }
 69     }
 70     /*
 71      *
 72      */
 73     public CompositeNode  search4Node(String passedNodeName, CompositeNode startingNode){
 74         if(null == startingNode)
 75             return (null);
 76 
 77         CompositeUserObject compositeUserObjectHandle = (CompositeUserObject)startingNode.getUserObject();
 78         String nodename = compositeUserObjectHandle.getNodeName();
 79         if(nodename.equalsIgnoreCase(passedNodeName))
 80             return(startingNode);
 81           
 82 //        if(startingNode.isLeaf())
 83 //            return(null);
 84 
 85        
 86         CompositeNode childNode = null;
 87         Enumeration treeEnumerationHandle = startingNode.children();
 88         while(treeEnumerationHandle.hasMoreElements())
 89         {
 90            childNode = (CompositeNode)treeEnumerationHandle.nextElement();
 91            compositeUserObjectHandle = (CompositeUserObject)childNode.getUserObject();
 92            nodename = compositeUserObjectHandle.getNodeName();
 93            if(nodename.equalsIgnoreCase(passedNodeName))
 94                break;
 95            if(childNode.isLeaf())
 96              childNode = null;
 97            else
 98            {
 99              childNode = search4Node(passedNodeName, childNode);
100              if(childNode != null)
101                break;
102            }
103         }
104         return(childNode);
105     }
106     /*
107      *
108      */
109     public int updateNode(String passedNodeName,
110                           String          newNodeName,
111                           boolean         passedProcessedFlag,
112                           long            passedUserObjectID) {
113         
114         CompositeNode  targetNode = search4Node(passedNodeName, CompositeNodeBase.ROOT);
115         if(null == targetNode)
116             return(CompositeNodeBase.NOT_NORMAL_RUN);
117 
118         CompositeUserObject compositeUserObjectHandle  = (CompositeUserObject)targetNode.getUserObject();
119         compositeUserObjectHandle.setNodeName(newNodeName);
120         compositeUserObjectHandle.setProcessedFlag(passedProcessedFlag);
121         compositeUserObjectHandle.setUserObjectID(passedUserObjectID);
122         targetNode.setUserObject(compositeUserObjectHandle);
123         return(CompositeNodeBase.NORMAL_RUN);
124     }
125     /*
126      *
127      */
128     public int deleteNode(CompositeNode targetNode){
129         if(null == targetNode)
130             return(CompositeNodeBase.NOT_NORMAL_RUN);
131 
132         // check if it is the ROOT
133         CompositeUserObject compositeUserObjectHandle = (CompositeUserObject)targetNode.getUserObject();
134         String nodename = compositeUserObjectHandle.getNodeName();
135         if(nodename.equalsIgnoreCase(CompositeNodeBase.ROOT_NODE_NAME))
136             return(CompositeNodeBase.NOT_NORMAL_RUN);
137 
138         // if it is a leaf
139         if(targetNode.isLeaf()){
140             targetNode = null;
141             Runtime.getRuntime().gc();
142             return(CompositeNodeBase.NORMAL_RUN);
143         }
144         //if node has a parent 
145         CompositeNode grandparentNode = (CompositeNode)targetNode.getParent();
146         // every node must have a parent except ROOT
147         if(null == grandparentNode)
148             return(CompositeNodeBase.NOT_NORMAL_RUN);
149         // let node's children has the grandparent for a parent
150         Enumeration treeEnumerationHandle = targetNode.children();
151         while(treeEnumerationHandle.hasMoreElements())
152         {
153                CompositeNode    childNode = (CompositeNode)treeEnumerationHandle.nextElement();
154                if(childNode != null)
155                     childNode.setParent(grandparentNode);
156          }
157         targetNode = null;
158         Runtime.getRuntime().gc();
159         return(CompositeNodeBase.NORMAL_RUN);
160     }
161     /*
162      *
163      */
164     public int deleteNode(String passedNodeName){
165         CompositeNode  targetNode = search4Node(passedNodeName, CompositeNodeBase.ROOT);
166         if(null == targetNode)
167             return(CompositeNodeBase.NOT_NORMAL_RUN);
168         
169         int returnValue = deleteNode(targetNode);
170         return(returnValue);
171     }
172                             
173 }
174 
175