/*******************************************************************************
* Copyright (c) 2000, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.core.internal.dtree;
import org.eclipse.core.runtime.IPath;
/**
* A <code>DataTree</code> represents the complete information of a source tree.
* The tree contains all information within its branches, and has no relation to any
* other source trees (no parent and no children).
*/
public class DataTree extends AbstractDataTree {
/**
* the root node of the tree
*/
private DataTreeNode rootNode;
/**
* Creates a new empty tree
*/
public DataTree() {
this.empty();
}
/**
* Returns a copy of the node subtree rooted at the given key.
*
* @param key
* Key of subtree to copy
*/
public AbstractDataTreeNode copyCompleteSubtree(IPath key) {
DataTreeNode node = findNodeAt(key);
if (node == null) {
handleNotFound(key);
}
return copyHierarchy(node);
}
/**
* Returns a deep copy of a node and all its children.
*
* @param node
* Node to be copied.
*/
DataTreeNode copyHierarchy(DataTreeNode node) {
DataTreeNode newNode;
int size = node.size();
if (size == 0) {
newNode = new DataTreeNode(node.getName(), node.getData());
} else {
AbstractDataTreeNode[] children = node.getChildren();
DataTreeNode[] newChildren = new DataTreeNode[size];
for (int i = size; --i >= 0;) {
newChildren[i] = this.copyHierarchy((DataTreeNode) children[i]);
}
newNode = new DataTreeNode(node.getName(), node.getData(), newChildren);
}
return newNode;
}
/**
* Creates a new child in the tree.
* @see AbstractDataTree#createChild(IPath, String)
*/
public void createChild(IPath parentKey, String localName) {
createChild(parentKey, localName, null);
}
/**
* Creates a new child in the tree.
* @see AbstractDataTree#createChild(IPath, String, Object)
*/
public void createChild(IPath parentKey, String localName, Object data) {
DataTreeNode node = findNodeAt(parentKey);
if (node == null)
handleNotFound(parentKey);
if (this.isImmutable())
handleImmutableTree();
/* If node already exists, replace */
if (node.includesChild(localName)) {
node.replaceChild(localName, new DataTreeNode(localName, data));
} else {
this.replaceNode(parentKey, node.copyWithNewChild(localName, new DataTreeNode(localName, data)));
}
}
/**
* Creates and returns an instance of the receiver. This is an
* implementation of the factory method creational pattern for allowing
* abstract methods to create instances
*/
protected AbstractDataTree createInstance() {
return new DataTree();
}
/**
* Creates or replaces a subtree in the tree. The parent node must exist.
*
* @param key
* Key of parent node whose subtree we want to create/replace.
* @param subtree
* New node to insert into tree.
*/
public void createSubtree(IPath key, AbstractDataTreeNode subtree) {
// Copy it since destructive mods are allowed on the original
// and shouldn't affect this tree.
DataTreeNode newNode = copyHierarchy((DataTreeNode) subtree);
if (this.isImmutable()) {
handleImmutableTree();
}
if (key.isRoot()) {
setRootNode(newNode);
} else {
String localName = key.lastSegment();
newNode.setName(localName); // Another mod, but it's OK we've already copied
IPath parentKey = key.removeLastSegments(1);
DataTreeNode node = findNodeAt(parentKey);
if (node == null) {
handleNotFound(parentKey);
}
/* If node already exists, replace */
if (node.includesChild(localName)) {
node.replaceChild(localName, newNode);
}
this.replaceNode(parentKey, node.copyWithNewChild(localName, newNode));
}
}
/**
* Deletes a child of the tree.
* @see AbstractDataTree#deleteChild(IPath, String)
*/
public void deleteChild(IPath parentKey, String localName) {
if (this.isImmutable())
handleImmutableTree();
DataTreeNode node = findNodeAt(parentKey);
if (node == null || (!node.includesChild(localName))) {
handleNotFound(node == null ? parentKey : parentKey.append(localName));
} else {
this.replaceNode(parentKey, node.copyWithoutChild(localName));
}
}
/**
* Initializes the receiver.
* @see AbstractDataTree#empty()
*/
public void empty() {
this.setRootNode(new DataTreeNode(null, null));
}
/**
* Returns the specified node if it is present, otherwise returns null.
*
* @param key
* Key of node to return
*/
public DataTreeNode findNodeAt(IPath key) {
AbstractDataTreeNode node = this.getRootNode();
int keyLength = key.segmentCount();
for (int i = 0; i < keyLength; i++) {
try {
node = node.childAt(key.segment(i));
} catch (ObjectNotFoundException notFound) {
return null;
}
}
return (DataTreeNode) node;
}
/**
* Returns the data at the specified node.
*
* @param key
* Node whose data to return.
*/
public Object getData(IPath key) {
DataTreeNode node = findNodeAt(key);
if (node == null) {
handleNotFound(key);
return null;
}
return node.getData();
}
/**
* Returns the names of the children of a node.
* @see AbstractDataTree#getNamesOfChildren(IPath)
*/
public String[] getNamesOfChildren(IPath parentKey) {
DataTreeNode parentNode;
parentNode = findNodeAt(parentKey);
if (parentNode == null) {
handleNotFound(parentKey);
return null;
}
return parentNode.namesOfChildren();
}
/**
* Returns the root node of the tree
*/
AbstractDataTreeNode getRootNode() {
return rootNode;
}
/**
* Returns true if the receiver includes a node with
* the given key, false otherwise.
*/
public boolean includes(IPath key) {
return (findNodeAt(key) != null);
}
/**
* Returns an object containing:
* - a flag indicating whether the specified node was found
* - the data for the node, if it was found
* @param key
* key of node for which we want to retrieve data.
*/
public DataTreeLookup lookup(IPath key) {
DataTreeNode node = this.findNodeAt(key);
if (node == null)
return DataTreeLookup.newLookup(key, false, null);
return DataTreeLookup.newLookup(key, true, node.getData());
}
/**
* Replaces the node at the specified key with the given node
*/
protected void replaceNode(IPath key, DataTreeNode node) {
DataTreeNode found;
if (key.isRoot()) {
this.setRootNode(node);
} else {
found = this.findNodeAt(key.removeLastSegments(1));
found.replaceChild(key.lastSegment(), node);
}
}
/**
* Sets the data at the specified node.
* @see AbstractDataTree#setData(IPath, Object)
*/
public void setData(IPath key, Object data) {
DataTreeNode node = this.findNodeAt(key);
if (this.isImmutable())
handleImmutableTree();
if (node == null) {
handleNotFound(key);
} else {
node.setData(data);
}
}
/**
* Sets the root node of the tree
* @see AbstractDataTree#setRootNode(AbstractDataTreeNode)
*/
void setRootNode(DataTreeNode aNode) {
rootNode = aNode;
}
}