Changeset 59
- Timestamp:
- 02/26/10 22:55:40 (2 years ago)
- Files:
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
kahina/trunk/src/org/kahina/data/tree/KahinaDbTree.java
r58 r59 13 13 import org.w3c.dom.NodeList; 14 14 15 public class KahinaDbTree extends KahinaTree { 15 public class KahinaDbTree extends KahinaTree 16 { 16 17 private static final String CLIENT_ID = KahinaDbTree.class.getName(); 17 18 … … 46 47 private PreparedStatement getRealChildrenStatement; 47 48 48 private PreparedStatement get VirtualChildrenStatement;49 private PreparedStatement getChildrenForLayerStatement; 49 50 50 51 private PreparedStatement getEdgeLabelStatement; … … 62 63 private int nextID; 63 64 64 public KahinaDbTree(DatabaseHandler db) { 65 public KahinaDbTree(DatabaseHandler db) 66 { 65 67 this(new DefaultLayerDecider(), db); 66 68 } 67 69 68 public KahinaDbTree(LayerDecider decider, DatabaseHandler db) { 70 public KahinaDbTree(LayerDecider decider, DatabaseHandler db) 71 { 69 72 super(decider); 70 73 this.db = db; … … 74 77 } 75 78 76 private void createTablesIfNecessary() { 77 if (!db.isRegistered(CLIENT_ID)) { 79 private void createTablesIfNecessary() 80 { 81 if (!db.isRegistered(CLIENT_ID)) 82 { 78 83 db.execute("CREATE TABLE " + NODE_TABLE_NAME + " (id INT, " 79 84 + "tree INT, " + "nodeCaption LONG VARCHAR, " … … 92 97 } 93 98 94 private void prepareStatements() { 99 private void prepareStatements() 100 { 95 101 int treeID = getID(); 96 102 addNodeStatement = db.prepareStatement("INSERT INTO " + NODE_TABLE_NAME … … 123 129 + NODE_TABLE_NAME + " WHERE realParent = ? AND tree = " 124 130 + treeID); 125 get VirtualChildrenStatement = db.prepareStatement("SELECT id FROM "131 getChildrenForLayerStatement = db.prepareStatement("SELECT id FROM " 126 132 + NODE_TABLE_NAME + " WHERE tree = " + treeID 127 133 + " AND (virtualParent = ? OR (realParent = ? AND layer < ?))"); … … 142 148 } 143 149 144 public void addNode(int id, String caption, String label, int nodeStatus) { 145 try { 150 public void addNode(int id, String caption, String label, int nodeStatus) 151 { 152 try 153 { 146 154 addNodeStatement.setInt(1, id); 147 155 addNodeStatement.setString(2, caption); … … 149 157 addNodeStatement.setInt(4, nodeStatus); 150 158 addNodeStatement.execute(); 151 } catch (SQLException e) { 159 } catch (SQLException e) 160 { 152 161 throw new KahinaException("SQL error.", e); 153 162 } … … 156 165 157 166 @Override 158 public int addNode(String caption, String label, int nodeStatus) { 167 public int addNode(String caption, String label, int nodeStatus) 168 { 159 169 int id = nextID++; 160 170 addNode(id, caption, label, nodeStatus); … … 163 173 164 174 @Override 165 public void addChild(int parent, int child) { 166 try { 175 public void addChild(int parent, int child) 176 { 177 try 178 { 167 179 addEdgeStatement.setInt(1, parent); 168 180 addEdgeStatement.setInt(2, child); 169 181 addEdgeStatement.execute(); 170 } catch (SQLException e) { 182 } catch (SQLException e) 183 { 171 184 throw new KahinaException("SQL error.", e); 172 185 } … … 174 187 } 175 188 176 private void computeAndStoreLayerInformation(int child) { 189 private void computeAndStoreLayerInformation(int child) 190 { 177 191 int childLayer = decider.decideOnLayer(child, this); 178 192 int virtualParent = getParent(child); 179 193 int parentLayer = getLayer(virtualParent); 180 while (parentLayer > childLayer) { 194 while (parentLayer > childLayer) 195 { 181 196 virtualParent = getParent(virtualParent); 182 197 parentLayer = getLayer(virtualParent); 183 198 } 184 if (parentLayer < childLayer) { 199 if (parentLayer < childLayer) 200 { 185 201 virtualParent = -1; 186 202 } 187 try { 203 try 204 { 188 205 addLayerInformationStatement.setInt(1, childLayer); 189 206 addLayerInformationStatement.setInt(2, virtualParent); 190 207 addLayerInformationStatement.setInt(3, child); 191 208 addLayerInformationStatement.execute(); 192 } catch (SQLException e) { 193 throw new KahinaException("SQL error.", e); 194 } 195 } 196 197 @Override 198 public void setLayerDecider(LayerDecider decider) { 209 } catch (SQLException e) 210 { 211 throw new KahinaException("SQL error.", e); 212 } 213 } 214 215 @Override 216 public void setLayerDecider(LayerDecider decider) 217 { 199 218 super.setLayerDecider(decider); 200 219 recomputeLayers(); 201 220 } 202 221 203 public void recomputeLayers() { 222 public void recomputeLayers() 223 { 204 224 recomputeLayers(getRootID()); 205 225 } 206 226 207 public void recomputeLayers(int nodeID) { 227 public void recomputeLayers(int nodeID) 228 { 208 229 computeAndStoreLayerInformation(nodeID); 209 for (int childID : getChildren(nodeID)) { 230 for (int childID : getChildren(nodeID)) 231 { 210 232 recomputeLayers(childID); 211 233 } … … 213 235 214 236 @Override 215 public int getParent(int nodeID) { 216 try { 237 public int getParent(int nodeID) 238 { 239 try 240 { 217 241 getRealParentStatement.setInt(1, nodeID); 218 } catch (SQLException e) { 242 } catch (SQLException e) 243 { 219 244 throw new KahinaException("SQL error.", e); 220 245 } … … 222 247 } 223 248 224 private int getVirtualParent(int nodeID) { 225 try { 249 private int getVirtualParent(int nodeID) 250 { 251 try 252 { 226 253 getVirtualParentStatement.setInt(1, nodeID); 227 } catch (SQLException e) { 254 } catch (SQLException e) 255 { 228 256 throw new KahinaException("SQL error.", e); 229 257 } … … 231 259 } 232 260 233 private int getLayer(int nodeID) { 234 try { 261 private int getLayer(int nodeID) 262 { 263 try 264 { 235 265 getLayerStatement.setInt(1, nodeID); 236 } catch (SQLException e) { 266 } catch (SQLException e) 267 { 237 268 throw new KahinaException("SQL error.", e); 238 269 } … … 241 272 242 273 @Override 243 public void clear() { 274 public void clear() 275 { 244 276 db.execute(clearStatement); 245 277 } 246 278 247 279 @Override 248 public void collapse(int nodeID) { 249 try { 280 public void collapse(int nodeID) 281 { 282 try 283 { 250 284 collapseStatement.setInt(1, nodeID); 251 285 collapseStatement.execute(); 252 } catch (SQLException e) { 253 throw new KahinaException("SQL error.", e); 254 } 255 } 256 257 @Override 258 public void decollapse(int nodeID) { 259 try { 286 } catch (SQLException e) 287 { 288 throw new KahinaException("SQL error.", e); 289 } 290 } 291 292 @Override 293 public void decollapse(int nodeID) 294 { 295 try 296 { 260 297 decollapseStatement.setInt(1, nodeID); 261 298 decollapseStatement.execute(); 262 } catch (SQLException e) { 263 throw new KahinaException("SQL error.", e); 264 } 265 } 266 267 @Override 268 public void decollapseAll() { 299 } catch (SQLException e) 300 { 301 throw new KahinaException("SQL error.", e); 302 } 303 } 304 305 @Override 306 public void decollapseAll() 307 { 269 308 db.execute(decollapseAllStatement); 270 309 } 271 310 272 311 @Override 273 public List<Integer> getChildren(int nodeID, int layer) { 312 public List<Integer> getChildren(int nodeID, int layer) 313 { 274 314 int nodeLayer = getLayer(nodeID); 275 if (layer == nodeLayer) { 315 if (layer == nodeLayer) 316 { 276 317 // the most common case, for which we have precalculated the virtual 277 318 // children 278 List<Integer> result = get VirtualChildren(nodeID, nodeLayer);319 List<Integer> result = getChildrenForLayer(nodeID, nodeLayer); 279 320 return result; 280 321 } 281 if (nodeID == getRootID(layer) || nodeLayer >= layer) { 322 if (nodeID == getRootID(layer) || nodeLayer >= layer) 323 { 282 324 // usually only the case for the root of a partial tree 283 325 List<Integer> frontLine = getChildren(nodeID); 284 for (int i = 0; i < frontLine.size();) { 326 for (int i = 0; i < frontLine.size();) 327 { 285 328 int child = frontLine.get(i); 286 if (getLayer(child) > layer) { 329 if (getLayer(child) > layer) 330 { 287 331 frontLine.remove(i); 288 332 frontLine.addAll(i, getChildren(child)); 289 } else { 333 } else 334 { 290 335 i++; 291 336 } … … 297 342 } 298 343 299 private List<Integer> getChildren(int nodeID) { 300 try { 344 private List<Integer> getChildren(int nodeID) 345 { 346 try 347 { 301 348 getRealChildrenStatement.setInt(1, nodeID); 302 } catch (SQLException e) { 349 } catch (SQLException e) 350 { 303 351 throw new KahinaException("SQL error.", e); 304 352 } … … 306 354 } 307 355 308 private List<Integer> getVirtualChildren(int nodeID, int layer) { 309 try { 310 getVirtualChildrenStatement.setInt(1, nodeID); 311 getVirtualChildrenStatement.setInt(2, nodeID); 312 getVirtualChildrenStatement.setInt(3, layer); 313 } catch (SQLException e) { 314 throw new KahinaException("SQL error.", e); 315 } 316 List<Integer> result = db.queryIntList(getVirtualChildrenStatement); 356 private List<Integer> getChildrenForLayer(int nodeID, int layer) 357 { 358 try 359 { 360 getChildrenForLayerStatement.setInt(1, nodeID); 361 getChildrenForLayerStatement.setInt(2, nodeID); 362 getChildrenForLayerStatement.setInt(3, layer); 363 } catch (SQLException e) 364 { 365 throw new KahinaException("SQL error.", e); 366 } 367 List<Integer> result = db.queryIntList(getChildrenForLayerStatement); 317 368 return result; 318 369 } 319 370 320 371 @Override 321 public String getEdgeLabel(int nodeID) { 322 try { 372 public String getEdgeLabel(int nodeID) 373 { 374 try 375 { 323 376 getEdgeLabelStatement.setInt(1, nodeID); 324 } catch (SQLException e) { 377 } catch (SQLException e) 378 { 325 379 throw new KahinaException("SQL error.", e); 326 380 } … … 329 383 330 384 @Override 331 protected void collectLeaves(int nodeID, List<Integer> leaves) { 385 protected void collectLeaves(int nodeID, List<Integer> leaves) 386 { 332 387 List<Integer> children = getChildren(nodeID); 333 if (children.isEmpty()) { 388 if (children.isEmpty()) 389 { 334 390 leaves.add(nodeID); 335 } else { 336 for (int child : children) { 391 } else 392 { 393 for (int child : children) 394 { 337 395 collectLeaves(child, leaves); 338 396 } … … 341 399 342 400 @Override 343 public String getNodeCaption(int nodeID) { 344 try { 401 public String getNodeCaption(int nodeID) 402 { 403 try 404 { 345 405 getNodeCaptionStatement.setInt(1, nodeID); 346 } catch (SQLException e) { 406 } catch (SQLException e) 407 { 347 408 throw new KahinaException("SQL error.", e); 348 409 } … … 351 412 352 413 @Override 353 public int getNodeStatus(int nodeID) { 354 try { 414 public int getNodeStatus(int nodeID) 415 { 416 try 417 { 355 418 getNodeStatusStatement.setInt(1, nodeID); 356 } catch (SQLException e) { 419 } catch (SQLException e) 420 { 357 421 throw new KahinaException("SQL error.", e); 358 422 } … … 361 425 362 426 @Override 363 public int getParent(int nodeID, int layer) { 364 if (nodeID == getRootID(layer)) { 427 public int getParent(int nodeID, int layer) 428 { 429 if (nodeID == getRootID(layer)) 430 { 365 431 return -1; 366 432 } 367 if (getLayer(nodeID) == layer) { 368 return getVirtualParent(nodeID); 433 if (getLayer(nodeID) == layer) 434 { 435 int virtualParent = getVirtualParent(nodeID); 436 if (virtualParent != -1) 437 { 438 return virtualParent; 439 } 369 440 } 370 441 int result = getParent(nodeID); 371 while (getLayer(result) > layer) { 442 while (getLayer(result) > layer) 443 { 372 444 result = getParent(result); 373 445 } … … 376 448 377 449 @Override 378 public int getRootID() { 450 public int getRootID() 451 { 379 452 return db.queryInteger(getRootStatement, -1); 380 453 } 381 454 382 455 @Override 383 public int getRootID(int layer) { 384 if (layer == 0) { 456 public int getRootID(int layer) 457 { 458 if (layer == 0) 459 { 385 460 return getRootID(); 386 461 } 387 462 int result = getReferenceNode(); 388 while (getLayer(result) >= layer) { 463 while (getLayer(result) >= layer) 464 { 389 465 result = getParent(result); 390 466 } … … 393 469 394 470 @Override 395 public boolean isCollapsed(int nodeID) { 396 try { 471 public boolean isCollapsed(int nodeID) 472 { 473 try 474 { 397 475 isCollapsedStatement.setInt(1, nodeID); 398 } catch (SQLException e) { 476 } catch (SQLException e) 477 { 399 478 throw new KahinaException("SQL error.", e); 400 479 } … … 404 483 405 484 @Override 406 public int getSize() { 485 public int getSize() 486 { 407 487 return db.queryInteger(getSizeStatement, 0); 408 488 } 409 489 410 490 public static KahinaTree importXML(Document dom, LayerDecider decider, 411 DatabaseHandler db, KahinaTree primaryModel) { 491 DatabaseHandler db, KahinaTree primaryModel) 492 { 412 493 KahinaDbTree m = new KahinaDbTree(decider, db); 413 if (primaryModel != null) { 494 if (primaryModel != null) 495 { 414 496 m.setPrimaryModel(primaryModel); 415 497 } 416 498 Element treeElement = dom.getDocumentElement(); 417 499 NodeList childNodes = treeElement.getChildNodes(); 418 for (int i = 0; i < childNodes.getLength(); i++) { 500 for (int i = 0; i < childNodes.getLength(); i++) 501 { 419 502 Node n = childNodes.item(i); 420 if (n.getNodeName().equals("node")) { 503 if (n.getNodeName().equals("node")) 504 { 421 505 importXMLNode(m, (Element) n, -1); 422 506 // TODO: a little risky, root node could be assigned another ID … … 428 512 } 429 513 430 private static void importXMLNode(KahinaDbTree m, Element node, int parentID) { 514 private static void importXMLNode(KahinaDbTree m, Element node, int parentID) 515 { 431 516 String caption = node.getAttribute("caption"); 432 517 String label = node.getAttribute("label"); 433 518 int status = 0; 434 if (node.getAttribute("status").length() > 0) { 519 if (node.getAttribute("status").length() > 0) 520 { 435 521 status = Integer.parseInt(node.getAttribute("status")); 436 522 } 437 523 int id; 438 if (node.getAttribute("id").length() > 0) { 524 if (node.getAttribute("id").length() > 0) 525 { 439 526 id = Integer.parseInt(node.getAttribute("id")); 440 527 m.addNode(id, caption, label, status); 441 } else { 528 } else 529 { 442 530 id = m.addNode(caption, label, status); 443 531 } 444 if (parentID != -1) { 532 if (parentID != -1) 533 { 445 534 m.addChild(parentID, id); 446 535 } 447 536 // go through children recursively 448 537 NodeList childNodes = node.getChildNodes(); 449 for (int i = 0; i < childNodes.getLength(); i++) { 538 for (int i = 0; i < childNodes.getLength(); i++) 539 { 450 540 Node n = childNodes.item(i); 451 if (n.getNodeName().equals("node")) { 541 if (n.getNodeName().equals("node")) 542 { 452 543 importXMLNode(m, (Element) n, id); 453 544 } … … 456 547 457 548 @Override 458 public void finalize() throws Throwable { 549 public void finalize() throws Throwable 550 { 459 551 clear(); 460 552 super.finalize(); kahina/trunk/src/org/kahina/visual/tree/KahinaTreeView.java
r57 r59 620 620 621 621 createNodeLayers(); 622 System.err.println(showLevels());622 //System.err.println(showLevels()); 623 623 //System.err.println(terminalLayer); 624 624 … … 758 758 while(true) 759 759 { 760 System.err.println("children:" + children);760 //System.err.println("children:" + children); 761 761 ArrayList<Integer> grandchildren = new ArrayList<Integer>(); 762 762 for (int i = 0; i < children.size(); i++)
