00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 package org.openmobileis.common.util.collection.tree;
00026
00027 import org.openmobileis.common.util.collection.Array;
00028
00036 public final class DependTree {
00037 private DependTreePhaseList firstPhase, currentPhase;
00038 private static Array emptyArray = new Array();
00039
00043 public DependTree() {
00044 super();
00045 }
00046
00047 public void clearTree() {
00048 emptyArray.clear();
00049 firstPhase=null;
00050 currentPhase=null;
00051 }
00052
00053 public Object getObjectByName(String listenerName) {
00054 DependTreePhaseList phase = firstPhase;
00055 while (phase != null) {
00056 DependNode node = this.getNodeFromPhaseList(listenerName);
00057 if (node != null) {
00058 return node.nodeObject;
00059 }
00060 phase = phase.nextPhase;
00061 }
00062 return null;
00063 }
00064
00065 public void addObject(String name, Object object, String[] dependList) {
00066 if (firstPhase == null) {
00067 firstPhase = new DependTreePhaseList(1);
00068 }
00069 Array depends = null;
00070 if (dependList == null) {
00071 depends = emptyArray;
00072 } else {
00073 depends = new Array(dependList);
00074 }
00075
00076 Array depArray = new Array();
00077 int dependssize = depends.size();
00078 for (int i=0; i<dependssize; i++) {
00079 DependNode depnode = new DependNode();
00080 depnode.nodeName = (String)depends.get(i);
00081 this.addDependNodeToList(depArray, firstPhase, depnode);
00082 }
00083
00084 DependNode newnode = new DependNode();
00085 newnode.nodeName = name;
00086 newnode.nodeObject = object;
00087
00088
00089 do {
00090 depends = this.addDependNodeToList(depends, firstPhase, newnode);
00091 } while (depends.size() != 0);
00092 }
00093
00094 public void resetPhaseList() {
00095
00096 DependTreePhaseList phase = firstPhase;
00097 while (phase != null) {
00098 int size = phase.nodeList.size();
00099 for (int i=0; i<size; i++) {
00100 DependNode node = (DependNode) phase.nodeList.get(i);
00101 node.validState = true;
00102 }
00103 phase = phase.nextPhase;
00104 }
00105 currentPhase = firstPhase;
00106 }
00107
00108 public Array getNextPhaseObjectList() {
00109 if (currentPhase == null) return DependTree.emptyArray;
00110 Array listenerList = new Array();
00111
00112 int size = currentPhase.nodeList.size();
00113 for (int i=0; i<size; i++) {
00114 DependNode node = (DependNode) currentPhase.nodeList.get(i);
00115 if (node.validState) {
00116 listenerList.add(node.nodeObject);
00117 }
00118 }
00119 currentPhase = currentPhase.nextPhase;
00120 return listenerList;
00121 }
00122
00123 public void invalidateNode(String listenerName) {
00124 DependNode listener = this.getNodeFromPhaseList(listenerName);
00125 if (listener != null) {
00126 invalidDependNodeChilds(listener);
00127 }
00128 }
00129
00130 protected void invalidDependNodeChilds(DependNode listener) {
00131 listener.validState = false;
00132 int size = listener.nexts.size();
00133 for (int i=0; i<size; i++) {
00134 this.invalidDependNodeChilds((DependNode)listener.nexts.get(i));
00135 }
00136 }
00137
00138 private DependNode getNodeFromPhaseList(String listenerName) {
00139 DependTreePhaseList phase = firstPhase;
00140 while (phase != null) {
00141 int size = phase.nodeList.size();
00142 for (int i=0; i<size; i++) {
00143 DependNode node = (DependNode) phase.nodeList.get(i);
00144 if (node.nodeName.equals(listenerName)) {
00145 return node;
00146 }
00147 }
00148 phase = phase.nextPhase;
00149 }
00150 return null;
00151 }
00152
00153 private Array addDependNodeToList(Array depends, DependTreePhaseList phase, DependNode newnode) {
00154
00155 int phasesize = phase.nodeList.size();
00156 DependNode phaseNode = null;
00157
00158
00159 for (int j=0; j<phasesize; j++) {
00160 phaseNode = (DependNode)phase.nodeList.get(j);
00161 if (newnode.nodeName.equals(phaseNode.nodeName)) {
00162 if (newnode.nodeObject != null) {
00163 phaseNode.nodeObject = newnode.nodeObject;
00164 }
00165
00166 newnode = phaseNode;
00167 }
00168 }
00169
00170
00171 if (depends.size() == 0) {
00172
00173 if ((newnode.nodePhase != null) && (newnode.nodePhase.phaseNumber < phase.phaseNumber)) {
00174 newnode.nodePhase.nodeList.remove(newnode);
00175 newnode.nodePhase = null;
00176 }
00177
00178 if (newnode.nodePhase == null) {
00179
00180 if(this.getNodeFromPhaseList(newnode.nodeName)== null) {
00181 newnode.nodePhase = phase;
00182 phase.nodeList.add(newnode);
00183 if (newnode.nexts.size() >0) {
00184
00185 movedependentListenerTonextPhase(newnode);
00186 }
00187 }
00188 }
00189 return DependTree.emptyArray;
00190 }
00191
00192
00193 Array newdepends = (Array)depends.clone();
00194 int dependssize = depends.size();
00195
00196 Array clonePhaseNodeList = (Array) phase.nodeList.clone();
00197 for (int i=0; i<dependssize; i++) {
00198 for (int j=0; j<phasesize; j++) {
00199 phaseNode = (DependNode)clonePhaseNodeList.get(j);
00200
00201 if (depends.get(i).equals(phaseNode.nodeName)) {
00202 newdepends.remove(phaseNode.nodeName);
00203 phaseNode.nexts.add(newnode);
00204 if (phase.nextPhase == null) {
00205 phase.nextPhase = new DependTreePhaseList(phase.phaseNumber+1);
00206 }
00207 newdepends = this.addDependNodeToList(newdepends, phase.nextPhase, newnode);
00208 }
00209 }
00210 if ((phase.nextPhase != null) && (depends.size() >0)) {
00211 newdepends = this.addDependNodeToList(newdepends, phase.nextPhase, newnode);
00212 }
00213 }
00214 return newdepends;
00215 }
00216
00217 private void movedependentListenerTonextPhase(DependNode node) {
00218 Array othernodelist = node.nexts;
00219 node.nexts = new Array();
00220 Array newdepends = new Array();
00221 newdepends.add(node.nodeName);
00222 for (int i=0; i<othernodelist.size(); i++) {
00223 DependNode listener = (DependNode) othernodelist.get(i);
00224
00225
00226 this.addDependNodeToList(newdepends, listener.nodePhase, listener);
00227 this.movedependentListenerTonextPhase(listener);
00228 }
00229
00230 }
00231 }
00232
00233