org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/backends/historytree/HistoryTree.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2013 Ericsson
   3  * Copyright (c) 2010, 2011 École Polytechnique de Montréal
   4  * Copyright (c) 2010, 2011 Alexandre Montplaisir <alexandre.montplaisir@gmail.com>
   5  *
   6  * All rights reserved. This program and the accompanying materials are
   7  * made available under the terms of the Eclipse Public License v1.0 which
   8  * accompanies this distribution, and is available at
   9  * http://www.eclipse.org/legal/epl-v10.html
  10  *
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.historytree;
  14
  15 import java.io.File;
  16 import java.io.FileInputStream;
  17 import java.io.IOException;
  18 import java.io.PrintWriter;
  19 import java.nio.ByteBuffer;
  20 import java.nio.ByteOrder;
  21 import java.nio.channels.ClosedChannelException;
  22 import java.nio.channels.FileChannel;
  23 import java.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.List;
  26
  27 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  28 import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateProvider;
  29
  30 /**
  31  * Meta-container for the History Tree. This structure contains all the
  32  * high-level data relevant to the tree.
  33  *
  34  * @author Alexandre Montplaisir
  35  */
  36 public class HistoryTree {
  37
  38     /**
  39      * Size of the "tree header" in the tree-file The nodes will use this offset
  40      * to know where they should be in the file. This should always be a
  41      * multiple of 4K.
  42      */
  43     public static final int TREE_HEADER_SIZE = 4096;
  44
  45     private static final int HISTORY_FILE_MAGIC_NUMBER = 0x05FFA900;
  46
  47     /** File format version. Increment when breaking compatibility. */
  48     private static final int FILE_VERSION = 3;
  49
  50     // ------------------------------------------------------------------------
  51     // Tree-specific configuration
  52     // ------------------------------------------------------------------------
  53
  54     /** Container for all the configuration constants */
  55     private final HTConfig config;
  56
  57     /** Reader/writer object */
  58     private final HT_IO treeIO;
  59
  60     // ------------------------------------------------------------------------
  61     // Variable Fields (will change throughout the existence of the SHT)
  62     // ------------------------------------------------------------------------
  63
  64     /** Latest timestamp found in the tree (at any given moment) */
  65     private long treeEnd;
  66
  67     /** The total number of nodes that exists in this tree */
  68     private int nodeCount;
  69
  70     /** "Cache" to keep the active nodes in memory */
  71     private List<CoreNode> latestBranch;
  72
  73     // ------------------------------------------------------------------------
  74     // Constructors/"Destructors"
  75     // ------------------------------------------------------------------------
  76
  77     /**
  78      * Create a new State History from scratch, using a {@link HTConfig} object
  79      * for configuration.
  80      *
  81      * @param conf
  82      *            The config to use for this History Tree.
  83      * @throws IOException
  84      *             If an error happens trying to open/write to the file
  85      *             specified in the config
  86      */
  87     public HistoryTree(HTConfig conf) throws IOException {
  88         /*
  89          * Simple check to make sure we have enough place in the 0th block
  90          * for the tree configuration
  91          */
  92         if (conf.getBlockSize() < TREE_HEADER_SIZE) {
  93             throw new IllegalArgumentException();
  94         }
  95
  96         config = conf;
  97         treeEnd = conf.getTreeStart();
  98         nodeCount = 0;
  99         latestBranch = new ArrayList<>();
 100
 101         /* Prepare the IO object */
 102         treeIO = new HT_IO(config, true);
 103
 104         /* Add the first node to the tree */
 105         CoreNode firstNode = initNewCoreNode(-1, conf.getTreeStart());
 106         latestBranch.add(firstNode);
 107     }
 108
 109     /**
 110      * "Reader" constructor : instantiate a SHTree from an existing tree file on
 111      * disk
 112      *
 113      * @param existingStateFile
 114      *            Path/filename of the history-file we are to open
 115      * @param expProviderVersion
 116      *            The expected version of the state provider
 117      * @throws IOException
 118      *             If an error happens reading the file
 119      */
 120     public HistoryTree(File existingStateFile, int expProviderVersion) throws IOException {
 121         /*
 122          * Open the file ourselves, get the tree header information we need,
 123          * then pass on the descriptor to the TreeIO object.
 124          */
 125         int rootNodeSeqNb, res;
 126         int bs, maxc;
 127         long startTime;
 128
 129         /* Java I/O mumbo jumbo... */
 130         if (!existingStateFile.exists()) {
 131             throw new IOException("Selected state file does not exist"); //$NON-NLS-1$
 132         }
 133         if (existingStateFile.length() <= 0) {
 134             throw new IOException("Empty target file"); //$NON-NLS-1$
 135         }
 136
 137         try (FileInputStream fis = new FileInputStream(existingStateFile);
 138                 FileChannel fc = fis.getChannel();) {
 139
 140             ByteBuffer buffer = ByteBuffer.allocate(TREE_HEADER_SIZE);
 141
 142             buffer.order(ByteOrder.LITTLE_ENDIAN);
 143             buffer.clear();
 144             fc.read(buffer);
 145             buffer.flip();
 146
 147             /*
 148              * Check the magic number to make sure we're opening the right type
 149              * of file
 150              */
 151             res = buffer.getInt();
 152             if (res != HISTORY_FILE_MAGIC_NUMBER) {
 153                 throw new IOException("Wrong magic number"); //$NON-NLS-1$
 154             }
 155
 156             res = buffer.getInt(); /* File format version number */
 157             if (res != FILE_VERSION) {
 158                 throw new IOException("Mismatching History Tree file format versions"); //$NON-NLS-1$
 159             }
 160
 161             res = buffer.getInt(); /* Event handler's version number */
 162             if (res != expProviderVersion &&
 163                     expProviderVersion != ITmfStateProvider.IGNORE_PROVIDER_VERSION) {
 164                 /*
 165                  * The existing history was built using an event handler that
 166                  * doesn't match the current one in the framework.
 167                  *
 168                  * Information could be all wrong. Instead of keeping an
 169                  * incorrect history file, a rebuild is done.
 170                  */
 171                 throw new IOException("Mismatching event handler versions"); //$NON-NLS-1$
 172             }
 173
 174             bs = buffer.getInt(); /* Block Size */
 175             maxc = buffer.getInt(); /* Max nb of children per node */
 176
 177             this.nodeCount = buffer.getInt();
 178             rootNodeSeqNb = buffer.getInt();
 179             startTime = buffer.getLong();
 180
 181             this.config = new HTConfig(existingStateFile, bs, maxc, expProviderVersion, startTime);
 182         }
 183
 184         /*
 185          * FIXME We close fis here and the TreeIO will then reopen the same
 186          * file, not extremely elegant. But how to pass the information here to
 187          * the SHT otherwise?
 188          */
 189         this.treeIO = new HT_IO(config, false);
 190
 191         rebuildLatestBranch(rootNodeSeqNb);
 192         this.treeEnd = latestBranch.get(0).getNodeEnd();
 193
 194         /*
 195          * Make sure the history start time we read previously is consistent
 196          * with was is actually in the root node.
 197          */
 198         if (startTime != latestBranch.get(0).getNodeStart()) {
 199             throw new IOException("Inconsistent start times in the" + //$NON-NLS-1$
 200                     "history file, it might be corrupted."); //$NON-NLS-1$
 201         }
 202     }
 203
 204     /**
 205      * "Save" the tree to disk. This method will cause the treeIO object to
 206      * commit all nodes to disk and then return the RandomAccessFile descriptor
 207      * so the Tree object can save its configuration into the header of the
 208      * file.
 209      *
 210      * @param requestedEndTime
 211      *            The greatest timestamp present in the history tree
 212      */
 213     public void closeTree(long requestedEndTime) {
 214         ByteBuffer buffer;
 215         int i, res;
 216
 217         /*
 218          * Work-around the "empty branches" that get created when the root node
 219          * becomes full. Overwrite the tree's end time with the original wanted
 220          * end-time, to ensure no queries are sent into those empty nodes.
 221          *
 222          * This won't be needed once extended nodes are implemented.
 223          */
 224         this.treeEnd = requestedEndTime;
 225
 226         /* Close off the latest branch of the tree */
 227         for (i = 0; i < latestBranch.size(); i++) {
 228             latestBranch.get(i).closeThisNode(treeEnd);
 229             treeIO.writeNode(latestBranch.get(i));
 230         }
 231
 232         try (FileChannel fc = treeIO.getFcOut();) {
 233             buffer = ByteBuffer.allocate(TREE_HEADER_SIZE);
 234             buffer.order(ByteOrder.LITTLE_ENDIAN);
 235             buffer.clear();
 236
 237             /* Save the config of the tree to the header of the file */
 238             fc.position(0);
 239
 240             buffer.putInt(HISTORY_FILE_MAGIC_NUMBER);
 241
 242             buffer.putInt(FILE_VERSION);
 243             buffer.putInt(config.getProviderVersion());
 244
 245             buffer.putInt(config.getBlockSize());
 246             buffer.putInt(config.getMaxChildren());
 247
 248             buffer.putInt(nodeCount);
 249
 250             /* root node seq. nb */
 251             buffer.putInt(latestBranch.get(0).getSequenceNumber());
 252
 253             /* start time of this history */
 254             buffer.putLong(latestBranch.get(0).getNodeStart());
 255
 256             buffer.flip();
 257             res = fc.write(buffer);
 258             assert (res <= TREE_HEADER_SIZE);
 259             /* done writing the file header */
 260
 261         } catch (IOException e) {
 262             /*
 263              * If we were able to write so far, there should not be any problem
 264              * at this point...
 265              */
 266             // FIXME still, the IOException should be propagated upwards
 267             throw new RuntimeException();
 268         }
 269         return;
 270     }
 271
 272     // ------------------------------------------------------------------------
 273     // Accessors
 274     // ------------------------------------------------------------------------
 275
 276     /**
 277      * Get the start time of this tree.
 278      *
 279      * @return The start time
 280      */
 281     public long getTreeStart() {
 282         return config.getTreeStart();
 283     }
 284
 285     /**
 286      * Get the current end time of this tree.
 287      *
 288      * @return The end time
 289      */
 290     public long getTreeEnd() {
 291         return treeEnd;
 292     }
 293
 294     /**
 295      * Get the number of nodes in this tree.
 296      *
 297      * @return The number of nodes
 298      */
 299     public int getNodeCount() {
 300         return nodeCount;
 301     }
 302
 303     /**
 304      * Return the latest (right-most) branch of nodes.
 305      *
 306      * @return The latest branch
 307      */
 308     public List<CoreNode> getLatestBranch() {
 309         return Collections.unmodifiableList(latestBranch);
 310     }
 311
 312     // ------------------------------------------------------------------------
 313     // HT_IO interface
 314     // ------------------------------------------------------------------------
 315
 316     /**
 317      * Return the FileInputStream reader with which we will read an attribute
 318      * tree (it will be sought to the correct position).
 319      *
 320      * @return The FileInputStream indicating the file and position from which
 321      *         the attribute tree can be read.
 322      */
 323     public FileInputStream supplyATReader() {
 324         return treeIO.supplyATReader(getNodeCount());
 325     }
 326
 327     /**
 328      * Return the file to which we will write the attribute tree.
 329      *
 330      * @return The file to which we will write the attribute tree
 331      */
 332     public File supplyATWriterFile() {
 333         return config.getStateFile();
 334     }
 335
 336     /**
 337      * Return the position in the file (given by {@link #supplyATWriterFile})
 338      * where to start writing the attribute tree.
 339      *
 340      * @return The position in the file where to start writing
 341      */
 342     public long supplyATWriterFilePos() {
 343         return HistoryTree.TREE_HEADER_SIZE
 344                 + ((long) getNodeCount() * config.getBlockSize());
 345     }
 346
 347     /**
 348      * Read a node from the tree.
 349      *
 350      * @param seqNumber
 351      *            The sequence number of the node to read
 352      * @return The node
 353      * @throws ClosedChannelException
 354      *             If the tree IO is unavailable
 355      */
 356     public HTNode readNode(int seqNumber) throws ClosedChannelException {
 357         /* Try to read the node from memory */
 358         for (HTNode node : getLatestBranch()) {
 359             if (node.getSequenceNumber() == seqNumber) {
 360                 return node;
 361             }
 362         }
 363
 364         /* Read the node from disk */
 365         return treeIO.readNode(seqNumber);
 366     }
 367
 368     /**
 369      * Write a node object to the history file.
 370      *
 371      * @param node
 372      *            The node to write to disk
 373      */
 374     public void writeNode(HTNode node) {
 375         treeIO.writeNode(node);
 376     }
 377
 378     /**
 379      * Close the history file.
 380      */
 381     public void closeFile() {
 382         treeIO.closeFile();
 383     }
 384
 385     /**
 386      * Delete the history file.
 387      */
 388     public void deleteFile() {
 389         treeIO.deleteFile();
 390     }
 391
 392     // ------------------------------------------------------------------------
 393     // Operations
 394     // ------------------------------------------------------------------------
 395
 396     /**
 397      * Rebuild the latestBranch "cache" object by reading the nodes from disk
 398      * (When we are opening an existing file on disk and want to append to it,
 399      * for example).
 400      *
 401      * @param rootNodeSeqNb
 402      *            The sequence number of the root node, so we know where to
 403      *            start
 404      * @throws ClosedChannelException
 405      */
 406     private void rebuildLatestBranch(int rootNodeSeqNb) throws ClosedChannelException {
 407         HTNode nextChildNode;
 408
 409         this.latestBranch = new ArrayList<>();
 410
 411         nextChildNode = treeIO.readNode(rootNodeSeqNb);
 412         latestBranch.add((CoreNode) nextChildNode);
 413         while (latestBranch.get(latestBranch.size() - 1).getNbChildren() > 0) {
 414             nextChildNode = treeIO.readNode(latestBranch.get(latestBranch.size() - 1).getLatestChild());
 415             latestBranch.add((CoreNode) nextChildNode);
 416         }
 417     }
 418
 419     /**
 420      * Insert an interval in the tree.
 421      *
 422      * @param interval
 423      *            The interval to be inserted
 424      * @throws TimeRangeException
 425      *             If the start of end time of the interval are invalid
 426      */
 427     public void insertInterval(HTInterval interval) throws TimeRangeException {
 428         if (interval.getStartTime() < config.getTreeStart()) {
 429             throw new TimeRangeException();
 430         }
 431         tryInsertAtNode(interval, latestBranch.size() - 1);
 432     }
 433
 434     /**
 435      * Inner method to find in which node we should add the interval.
 436      *
 437      * @param interval
 438      *            The interval to add to the tree
 439      * @param indexOfNode
 440      *            The index *in the latestBranch* where we are trying the
 441      *            insertion
 442      */
 443     private void tryInsertAtNode(HTInterval interval, int indexOfNode) {
 444         HTNode targetNode = latestBranch.get(indexOfNode);
 445
 446         /* Verify if there is enough room in this node to store this interval */
 447         if (interval.getIntervalSize() > targetNode.getNodeFreeSpace()) {
 448             /* Nope, not enough room. Insert in a new sibling instead. */
 449             addSiblingNode(indexOfNode);
 450             tryInsertAtNode(interval, latestBranch.size() - 1);
 451             return;
 452         }
 453
 454         /* Make sure the interval time range fits this node */
 455         if (interval.getStartTime() < targetNode.getNodeStart()) {
 456             /*
 457              * No, this interval starts before the startTime of this node. We
 458              * need to check recursively in parents if it can fit.
 459              */
 460             assert (indexOfNode >= 1);
 461             tryInsertAtNode(interval, indexOfNode - 1);
 462             return;
 463         }
 464
 465         /*
 466          * Ok, there is room, and the interval fits in this time slot. Let's add
 467          * it.
 468          */
 469         targetNode.addInterval(interval);
 470
 471         /* Update treeEnd if needed */
 472         if (interval.getEndTime() > this.treeEnd) {
 473             this.treeEnd = interval.getEndTime();
 474         }
 475     }
 476
 477     /**
 478      * Method to add a sibling to any node in the latest branch. This will add
 479      * children back down to the leaf level, if needed.
 480      *
 481      * @param indexOfNode
 482      *            The index in latestBranch where we start adding
 483      */
 484     private void addSiblingNode(int indexOfNode) {
 485         int i;
 486         CoreNode newNode, prevNode;
 487         long splitTime = treeEnd;
 488
 489         assert (indexOfNode < latestBranch.size());
 490
 491         /* Check if we need to add a new root node */
 492         if (indexOfNode == 0) {
 493             addNewRootNode();
 494             return;
 495         }
 496
 497         /* Check if we can indeed add a child to the target parent */
 498         if (latestBranch.get(indexOfNode - 1).getNbChildren() == config.getMaxChildren()) {
 499             /* If not, add a branch starting one level higher instead */
 500             addSiblingNode(indexOfNode - 1);
 501             return;
 502         }
 503
 504         /* Split off the new branch from the old one */
 505         for (i = indexOfNode; i < latestBranch.size(); i++) {
 506             latestBranch.get(i).closeThisNode(splitTime);
 507             treeIO.writeNode(latestBranch.get(i));
 508
 509             prevNode = latestBranch.get(i - 1);
 510             newNode = initNewCoreNode(prevNode.getSequenceNumber(),
 511                     splitTime + 1);
 512             prevNode.linkNewChild(newNode);
 513
 514             latestBranch.set(i, newNode);
 515         }
 516     }
 517
 518     /**
 519      * Similar to the previous method, except here we rebuild a completely new
 520      * latestBranch
 521      */
 522     private void addNewRootNode() {
 523         int i, depth;
 524         CoreNode oldRootNode, newRootNode, newNode, prevNode;
 525         long splitTime = this.treeEnd;
 526
 527         oldRootNode = latestBranch.get(0);
 528         newRootNode = initNewCoreNode(-1, config.getTreeStart());
 529
 530         /* Tell the old root node that it isn't root anymore */
 531         oldRootNode.setParentSequenceNumber(newRootNode.getSequenceNumber());
 532
 533         /* Close off the whole current latestBranch */
 534         for (i = 0; i < latestBranch.size(); i++) {
 535             latestBranch.get(i).closeThisNode(splitTime);
 536             treeIO.writeNode(latestBranch.get(i));
 537         }
 538
 539         /* Link the new root to its first child (the previous root node) */
 540         newRootNode.linkNewChild(oldRootNode);
 541
 542         /* Rebuild a new latestBranch */
 543         depth = latestBranch.size();
 544         latestBranch = new ArrayList<>();
 545         latestBranch.add(newRootNode);
 546         for (i = 1; i < depth + 1; i++) {
 547             prevNode = latestBranch.get(i - 1);
 548             newNode = initNewCoreNode(prevNode.getParentSequenceNumber(),
 549                     splitTime + 1);
 550             prevNode.linkNewChild(newNode);
 551             latestBranch.add(newNode);
 552         }
 553     }
 554
 555     /**
 556      * Add a new empty node to the tree.
 557      *
 558      * @param parentSeqNumber
 559      *            Sequence number of this node's parent
 560      * @param startTime
 561      *            Start time of the new node
 562      * @return The newly created node
 563      */
 564     private CoreNode initNewCoreNode(int parentSeqNumber, long startTime) {
 565         CoreNode newNode = new CoreNode(config, this.nodeCount, parentSeqNumber,
 566                 startTime);
 567         this.nodeCount++;
 568
 569         /* Update the treeEnd if needed */
 570         if (startTime >= this.treeEnd) {
 571             this.treeEnd = startTime + 1;
 572         }
 573         return newNode;
 574     }
 575
 576     /**
 577      * Inner method to select the next child of the current node intersecting
 578      * the given timestamp. Useful for moving down the tree following one
 579      * branch.
 580      *
 581      * @param currentNode
 582      *            The node on which the request is made
 583      * @param t
 584      *            The timestamp to choose which child is the next one
 585      * @return The child node intersecting t
 586      * @throws ClosedChannelException
 587      *             If the file channel was closed while we were reading the tree
 588      */
 589     public HTNode selectNextChild(CoreNode currentNode, long t) throws ClosedChannelException {
 590         assert (currentNode.getNbChildren() > 0);
 591         int potentialNextSeqNb = currentNode.getSequenceNumber();
 592
 593         for (int i = 0; i < currentNode.getNbChildren(); i++) {
 594             if (t >= currentNode.getChildStart(i)) {
 595                 potentialNextSeqNb = currentNode.getChild(i);
 596             } else {
 597                 break;
 598             }
 599         }
 600
 601         /*
 602          * Once we exit this loop, we should have found a children to follow. If
 603          * we didn't, there's a problem.
 604          */
 605         assert (potentialNextSeqNb != currentNode.getSequenceNumber());
 606
 607         /*
 608          * Since this code path is quite performance-critical, avoid iterating
 609          * through the whole latestBranch array if we know for sure the next
 610          * node has to be on disk
 611          */
 612         if (currentNode.isOnDisk()) {
 613             return treeIO.readNode(potentialNextSeqNb);
 614         }
 615         return readNode(potentialNextSeqNb);
 616     }
 617
 618     /**
 619      * Get the current size of the history file.
 620      *
 621      * @return The history file size
 622      */
 623     public long getFileSize() {
 624         return config.getStateFile().length();
 625     }
 626
 627     // ------------------------------------------------------------------------
 628     // Test/debugging methods
 629     // ------------------------------------------------------------------------
 630
 631     /**
 632      * Debugging method to make sure all intervals contained in the given node
 633      * have valid start and end times.
 634      *
 635      * @param zenode
 636      *            The node to check
 637      * @return True if everything is fine, false if there is at least one
 638      *         invalid timestamp (end time < start time, time outside of the
 639      *         range of the node, etc.)
 640      */
 641     @SuppressWarnings("nls")
 642     public boolean checkNodeIntegrity(HTNode zenode) {
 643         /* Only used for debugging, shouldn't be externalized */
 644         HTNode otherNode;
 645         CoreNode node;
 646         StringBuffer buf = new StringBuffer();
 647         boolean ret = true;
 648
 649         // FIXME /* Only testing Core Nodes for now */
 650         if (!(zenode instanceof CoreNode)) {
 651             return true;
 652         }
 653
 654         node = (CoreNode) zenode;
 655
 656         try {
 657             /*
 658              * Test that this node's start and end times match the start of the
 659              * first child and the end of the last child, respectively
 660              */
 661             if (node.getNbChildren() > 0) {
 662                 otherNode = treeIO.readNode(node.getChild(0));
 663                 if (node.getNodeStart() != otherNode.getNodeStart()) {
 664                     buf.append("Start time of node (" + node.getNodeStart() + ") "
 665                             + "does not match start time of first child " + "("
 666                             + otherNode.getNodeStart() + "), " + "node #"
 667                             + otherNode.getSequenceNumber() + ")\n");
 668                     ret = false;
 669                 }
 670                 if (node.isOnDisk()) {
 671                     otherNode = treeIO.readNode(node.getLatestChild());
 672                     if (node.getNodeEnd() != otherNode.getNodeEnd()) {
 673                         buf.append("End time of node (" + node.getNodeEnd()
 674                                 + ") does not match end time of last child ("
 675                                 + otherNode.getNodeEnd() + ", node #"
 676                                 + otherNode.getSequenceNumber() + ")\n");
 677                         ret = false;
 678                     }
 679                 }
 680             }
 681
 682             /*
 683              * Test that the childStartTimes[] array matches the real nodes' start
 684              * times
 685              */
 686             for (int i = 0; i < node.getNbChildren(); i++) {
 687                 otherNode = treeIO.readNode(node.getChild(i));
 688                 if (otherNode.getNodeStart() != node.getChildStart(i)) {
 689                     buf.append("  Expected start time of child node #"
 690                             + node.getChild(i) + ": " + node.getChildStart(i)
 691                             + "\n" + "  Actual start time of node #"
 692                             + otherNode.getSequenceNumber() + ": "
 693                             + otherNode.getNodeStart() + "\n");
 694                     ret = false;
 695                 }
 696             }
 697
 698         } catch (ClosedChannelException e) {
 699             e.printStackTrace();
 700         }
 701
 702         if (!ret) {
 703             System.out.println("");
 704             System.out.println("SHT: Integrity check failed for node #"
 705                     + node.getSequenceNumber() + ":");
 706             System.out.println(buf.toString());
 707         }
 708         return ret;
 709     }
 710
 711     /**
 712      * Check the integrity of all the nodes in the tree. Calls
 713      * {@link #checkNodeIntegrity} for every node in the tree.
 714      */
 715     public void checkIntegrity() {
 716         try {
 717             for (int i = 0; i < nodeCount; i++) {
 718                 checkNodeIntegrity(treeIO.readNode(i));
 719             }
 720         } catch (ClosedChannelException e) {
 721         }
 722     }
 723
 724     /* Only used for debugging, shouldn't be externalized */
 725     @SuppressWarnings("nls")
 726     @Override
 727     public String toString() {
 728         return "Information on the current tree:\n\n" + "Blocksize: "
 729                 + config.getBlockSize() + "\n" + "Max nb. of children per node: "
 730                 + config.getMaxChildren() + "\n" + "Number of nodes: " + nodeCount
 731                 + "\n" + "Depth of the tree: " + latestBranch.size() + "\n"
 732                 + "Size of the treefile: " + this.getFileSize() + "\n"
 733                 + "Root node has sequence number: "
 734                 + latestBranch.get(0).getSequenceNumber() + "\n"
 735                 + "'Latest leaf' has sequence number: "
 736                 + latestBranch.get(latestBranch.size() - 1).getSequenceNumber();
 737     }
 738
 739     /**
 740      * Start at currentNode and print the contents of all its children, in
 741      * pre-order. Give the root node in parameter to visit the whole tree, and
 742      * have a nice overview.
 743      */
 744     /* Only used for debugging, shouldn't be externalized */
 745     @SuppressWarnings("nls")
 746     private void preOrderPrint(PrintWriter writer, boolean printIntervals,
 747             CoreNode currentNode, int curDepth) {
 748
 749         writer.println(currentNode.toString());
 750         if (printIntervals) {
 751             currentNode.debugPrintIntervals(writer);
 752         }
 753
 754         try {
 755             for (int i = 0; i < currentNode.getNbChildren(); i++) {
 756                 HTNode nextNode = treeIO.readNode(currentNode.getChild(i));
 757                 assert (nextNode instanceof CoreNode); // TODO temporary
 758                 for (int j = 0; j < curDepth; j++) {
 759                     writer.print("  ");
 760                 }
 761                 writer.print("+-");
 762                 preOrderPrint(writer, printIntervals, (CoreNode) nextNode,
 763                               curDepth + 1);
 764             }
 765         } catch (ClosedChannelException e) {
 766             e.printStackTrace();
 767         }
 768     }
 769
 770     /**
 771      * Print out the full tree for debugging purposes
 772      *
 773      * @param writer
 774      *            PrintWriter in which to write the output
 775      * @param printIntervals
 776      *            Flag to enable full output of the interval information
 777      */
 778     public void debugPrintFullTree(PrintWriter writer, boolean printIntervals) {
 779         /* Only used for debugging, shouldn't be externalized */
 780
 781         this.preOrderPrint(writer, false, latestBranch.get(0), 0);
 782
 783         if (printIntervals) {
 784             writer.println("\nDetails of intervals:"); //$NON-NLS-1$
 785             this.preOrderPrint(writer, true, latestBranch.get(0), 0);
 786         }
 787         writer.println('\n');
 788     }
 789
 790 }