Examples of org.eclipse.core.internal.watson.ElementTree$ChildIDsCache

Package org.eclipse.core.internal.watson

Examples of org.eclipse.core.internal.watson.ElementTree$ChildIDsCache

org.eclipse.core.internal.watson.ElementTree
An ElementTree can be viewed as a generic rooted tree that stores a hierarchy of elements. An element in the tree consists of a (name, data, children) 3-tuple. The name can be any String, and the data can be any Object. The children are a collection of zero or more elements that logically fall below their parent in the tree. The implementation makes no guarantees about the ordering of children. Elements in the tree are referenced by a key that consists of the names of all elements on the path from the root to that element in the tree. For example, if root node "a" has child "b", which has child "c", element "c" can be referenced in the tree using the key (/a/b/c). Keys are represented using IPath objects, where the Paths are relative to the root element of the tree. @see IPath Each ElementTree has a single root element that is created implicitly and is always present in any tree. This root corresponds to the key (/), or the singleton Path.ROOT. The root element cannot be created or deleted, and its data and name cannot be set. The root element's children however can be modified (added, deleted, etc). The root path can be obtained using the getRoot() method. ElementTrees are modified in generations. The method newEmptyDelta() returns a new tree generation that can be modified arbitrarily by the user. For the purpose of explanation, we call such a tree "active". When the method immutable() is called, that tree generation is frozen, and can never again be modified. A tree must be immutable before a new tree generation can start. Since all ancestor trees are immutable, different active trees can have ancestors in common without fear of thread corruption problems. Internally, any single tree generation is simply stored as the set of changes between itself and its most recent ancestor (its parent). This compact delta representation allows chains of element trees to be created at relatively low cost. Clients of the ElementTree can instantaneously "undo" sets of changes by navigating up to the parent tree using the getParent() method. Although the delta representation is compact, extremely long delta chains make for a large structure that is potentially slow to query. For this reason, the client is encouraged to minimize delta chain lengths using the collapsing(int) and makeComplete() methods. The getDeltaDepth() method can be used to discover the length of the delta chain. The entire delta chain can also be re-oriented in terms of the current element tree using the reroot() operation. Classes are also available for tree serialization and navigation. @see ElementTreeReader @see ElementTreeWriter @see ElementTreeIterator Finally, why are ElementTrees in a package called "watson"? - "It's ElementTree my dear Watson, ElementTree."

        // Be sure to clean up after ourselves.
        if (clean || currentBuilder.wasForgetStateRequested()) {
          currentBuilder.setLastBuiltTree(null);
        } else {
          // remember the current state as the last built state.
          ElementTree lastTree = workspace.getElementTree();
          lastTree.immutable();
          currentBuilder.setLastBuiltTree(lastTree);
        }
        hookEndBuild(builder);
      }
    } finally {

View Full Code Here

      if (builder == null) {
        // if the builder was not instantiated, use the old info if any.
        if (oldInfos != null)
          info = getBuilderInfo(oldInfos, builderName, i);
      } else if (!(builder instanceof MissingBuilder)) {
        ElementTree oldTree = ((InternalBuilder) builder).getLastBuiltTree();
        //don't persist build state for builders that have no last built state
        if (oldTree != null) {
          // if the builder was instantiated, construct a memento with the important info
          info = new BuilderPersistentInfo(project.getName(), builderName, i);
          info.setLastBuildTree(oldTree);

View Full Code Here

    ArrayList infos = getBuildersPersistentInfo(project);
    if (infos != null) {
      BuilderPersistentInfo info = getBuilderInfo(infos, builderName, buildSpecIndex);
      if (info != null) {
        infos.remove(info);
        ElementTree tree = info.getLastBuiltTree();
        if (tree != null)
          ((InternalBuilder) builder).setLastBuiltTree(tree);
        ((InternalBuilder) builder).setInterestingProjects(info.getInterestingProjects());
      }
      // delete the build map if it's now empty

View Full Code Here

          return true;
        //fall through and check if there is a delta
    }


    //compute the delta since the last built state
    ElementTree oldTree = builder.getLastBuiltTree();
    ElementTree newTree = workspace.getElementTree();
    long start = System.currentTimeMillis();
    currentDelta = (DeltaDataTree) deltaTreeCache.getDelta(null, oldTree, newTree);
    if (currentDelta == null) {
      if (Policy.DEBUG_BUILD_NEEDED) {
        String message = "Checking if need to build. Starting delta computation between: " + oldTree.toString() + " and " + newTree.toString(); //$NON-NLS-1$ //$NON-NLS-2$
        Policy.debug(message);
      }
      currentDelta = newTree.getDataTree().forwardDeltaWith(oldTree.getDataTree(), ResourceComparator.getBuildComparator());
      if (Policy.DEBUG_BUILD_NEEDED)
        Policy.debug("End delta computation. (" + (System.currentTimeMillis() - start) + "ms)."); //$NON-NLS-1$ //$NON-NLS-2$
      deltaTreeCache.cache(null, oldTree, newTree, currentDelta);
    }

View Full Code Here

        Map markerDeltas = workspace.getMarkerManager().getMarkerDeltas(lastPostBuildId);
        lastDelta.updateMarkers(markerDeltas);
      }
    } else {
      // We don't have a delta or something changed so recompute the whole deal.
      ElementTree oldTree = postChange ? lastPostChangeTree : lastPostBuildTree;
      long markerId = postChange ? lastPostChangeId : lastPostBuildId;
      lastDelta = ResourceDeltaFactory.computeDelta(workspace, oldTree, tree, Path.ROOT, markerId + 1);
    }
    // remember the state of the world when this delta was consistent
    lastDeltaState = tree;

View Full Code Here

      ElementTree[] trees = treeReader.readDeltaChain(input);
      monitor.worked(3);
      if (root.isRoot()) {
        //Don't need to link because we're reading the whole workspace.
        //The last tree in the chain is the complete tree.
        ElementTree newTree = trees[trees.length - 1];
        newTree.setTreeData(workspace.tree.getTreeData());
        workspace.tree = newTree;
      } else {
        //splice the restored tree into the current set of trees
        workspace.linkTrees(root, trees);
      }

View Full Code Here

TOP

Related Classes of org.eclipse.core.internal.watson.ElementTree$ChildIDsCache

org.eclipse.core.internal.events.BuildManager

org.eclipse.core.internal.events.NotificationManager

org.eclipse.core.internal.resources.WorkspaceTreeReader_1

java.util.HashMap

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.