import org.eclipse.core.resources.IResourceDelta;

import org.eclipse.wst.common.componentcore.resources.VirtualTreeNode;

	public VirtualTreeNode getVirtualTreeRoot() {

		return null;

	}

import org.eclipse.core.resources.IResource;

import org.eclipse.wst.common.componentcore.internal.ComponentResource;

import org.eclipse.wst.common.componentcore.resources.VirtualTreeNode;

	protected List<VirtualTreeNode.Entry> getVirtualTreeRootEntries() throws CoreException {

		final List<VirtualTreeNode.Entry> entries = new ArrayList<VirtualTreeNode.Entry>();

		StructureEdit core = StructureEdit.getStructureEditForRead(getProject());

		try {

			if (core != null) {

				WorkbenchComponent component = core.getComponent();

				if (component != null) {

					List resources = component.getResources();

					Iterator resIter = resources.iterator();

					while (resIter.hasNext()) {

						ComponentResource componentResource = (ComponentResource) resIter.next();

						IResource resource = getProject().findMember(componentResource.getSourcePath());

						if (resource != null && resource.exists()) {

							entries.add(new VirtualTreeNode.Entry(componentResource.getRuntimePath(), resource));

						} else {

							// TODO warn 

						}

					}

				}

			}

		} finally {

			if(core != null)

				core.dispose();

		}

		return entries;

	}

	public VirtualTreeNode getVirtualTreeRoot() throws CoreException {

		return new VirtualTreeNode(getVirtualTreeRootEntries());

	}

	public VirtualTreeNode getVirtualTreeRoot() throws CoreException;

#Sat Aug 19 23:14:33 EDT 2006

eclipse.preferences.version=1

org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled

org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5

org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve

org.eclipse.jdt.core.compiler.compliance=1.5

org.eclipse.jdt.core.compiler.debug.lineNumber=generate

org.eclipse.jdt.core.compiler.debug.localVariable=generate

org.eclipse.jdt.core.compiler.debug.sourceFile=generate

org.eclipse.jdt.core.compiler.problem.assertIdentifier=error

org.eclipse.jdt.core.compiler.problem.enumIdentifier=error

org.eclipse.jdt.core.compiler.source=1.5

package org.eclipse.wst.common.componentcore.resources;

import java.io.File;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.eclipse.core.resources.IContainer;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IResourceDelta;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.Path;

public class VirtualTreeNode {

	public static class Entry {

		private final IPath runtimePath;

		private final IResource resource;

		private final File file;

		private final VirtualTreeNode node;

		private final IResourceDelta delta;

		protected Entry(IPath runtimePath, IResource resource, File file, VirtualTreeNode node, IResourceDelta delta) {

			this.runtimePath = runtimePath == null || runtimePath.segmentCount() == 0? null: runtimePath;

			this.resource = resource;

			this.file = file;

			this.node = node;

			this.delta = delta;

		}

		public Entry(IPath runtimePath, IResource resource) {

			this(runtimePath, resource, null, null, null);

		}

		public Entry(IPath runtimePath, IResource resource, IResourceDelta delta) {

			this(runtimePath, resource, null, null, delta);

		}

		public Entry(IPath runtimePath, VirtualTreeNode node) {

			this(runtimePath, null, null, node, null);

		}

		public Entry(IPath runtimePath, File file) {

			this(runtimePath, null, file, null, null);

		}

		public IPath getRuntimePath() {

			return runtimePath;

		}

		public IResource getResource() {

			return resource;

		}

		public File getFile() {

			return file;

		}

		public VirtualTreeNode getNode() {

			return node;

		}

		public IResourceDelta getResourceDelta() {

			return delta;

		}

	}

	public interface IEntryFilter {

		public boolean accept(Entry entry);

	}

	protected final IPath runtimePath;

	protected final List<Entry> entries;

	protected final boolean isDelta;

	/**

	 * This contructor should only be called from other constructors and never

	 * directly. #newVirtualTreeNode should be called from all other methods 

	 * to ensure creation of proper subclass. 

	 * 

	 * @param runtimePath

	 * @param entries

	 * @param isDelta

	 */

	protected VirtualTreeNode(IPath runtimePath, List<Entry> entries, boolean isDelta) {

		this.runtimePath = runtimePath;

		this.entries = entries;

		this.isDelta = isDelta;

	}

	public VirtualTreeNode(List<Entry> entries) {

		this(Path.ROOT, entries, false);

	}

	public VirtualTreeNode filter(IEntryFilter filter) {

		ArrayList<Entry> result = new ArrayList<Entry>(entries.size());

		for (Entry entry : entries) {

			if (filter.accept(entry)) {

				VirtualTreeNode node = entry.getNode();

				if (node != null) {

					result.add(new Entry(entry.getRuntimePath(), node.filter(filter)));

				} else {

					result.add(entry);

				}

			}

		}

		return newVirtualTreeNode(getRuntimePath(), result, isDelta);

	}

	private List<VirtualTreeNode> members;

	public List<VirtualTreeNode> members() throws CoreException {

		if (members == null) {

			members = internalMembers();

		}

		return members;

	}

	private List<VirtualTreeNode> internalMembers() throws CoreException {

		List<VirtualTreeNode> result = new ArrayList<VirtualTreeNode>();

		Set<String> names = new HashSet<String>();

		for (int i = 0; i < entries.size(); i++) {

			Entry entry = entries.get(i);

			IResource resource = entry.getResource();

			File file = entry.getFile();

			VirtualTreeNode node = entry.getNode();

			IResourceDelta delta = entry.getResourceDelta();

			if (entry.getRuntimePath() == null) { // mounted into this folder

				if (resource != null && hasChildren(entry)) {

					IResource[] children = ((IContainer) resource).members();

					for (IResource child : children) {

						String name = child.getName();

						if (names.add(name)) {

							addNotNull(result, internalNewMember(i, name, newEntry(null, child, null, null, delta)));

						}

					}

				}

				if (file != null && file.isDirectory() && !isDelta) {

					File[] children = file.listFiles();

					for (File child : children) {

						String name = child.getName();

						if (names.add(name)) {

							addNotNull(result, internalNewMember(i, name, newEntry(null, null, child, null, null)));

						}

					}

				}

				if (node != null) {

					List<VirtualTreeNode> children = node.members();

					for (VirtualTreeNode child : children) {

						String name = child.getName();

						if (names.add(name)) {

							addNotNull(result, internalNewMember(i, name, newEntry(null, null, null, child, null)));

						}

					}

				}

			} else {

				String name = entry.getRuntimePath().segment(0);

				// TODO make sure name is not null/empty

				if (names.add(name)) {

					addNotNull(result, internalNewMember(i, name, newEntry(entry.getRuntimePath().removeFirstSegments(1), resource, file, node, delta)));

				}

			}

		}

		return result;

	}

	private static void addNotNull(List<VirtualTreeNode> result, VirtualTreeNode node) {

		if (node != null) {

			result.add(node);

		}

	}

	public String getName() {

		return runtimePath.lastSegment();

	}

	static Entry newEntry(IPath runtimePath, IResource resource, File file, VirtualTreeNode node, IResourceDelta delta) {

		if (runtimePath == null && resource != null && delta != null) {

			delta = findMember(delta, resource.getFullPath());

		}

		return new Entry(runtimePath, resource, file, node, delta);

	}

	private boolean hasChildren(Entry entry) {

		if (entry.getResource() instanceof IFile) return false;

		if (!isDelta) return true;

		IResourceDelta delta = entry.getResourceDelta();

		if (delta == null) return false;

		IPath resourcePath = entry.getResource().getFullPath();

		IResourceDelta member = findMember(delta, resourcePath);

		return member != null;

	}

	private VirtualTreeNode internalNewMember(int idx, final String name, Entry childEntry) throws CoreException {

		ArrayList<Entry> childEntries = new ArrayList<Entry>();

		childEntries.add(childEntry);

		// gather rest of the child's entries

		for (int i = idx + 1; i < entries.size(); i++) {

			Entry entry = entries.get(i);

			IResource resource = entry.getResource();

			File file = entry.getFile();

			VirtualTreeNode node = entry.getNode();

			IResourceDelta delta = entry.getResourceDelta();

			if (entry.getRuntimePath() == null) {

				if (resource != null) {

					IResource childResource = ((IContainer) resource).findMember(name);

					if (childResource != null) {

						childEntries.add(newEntry(null, childResource, null, null, delta));

					}

				}

				if (file != null) {

					File childFile = findMember(file, name);

					if (childFile != null) {

						childEntries.add(newEntry(null, null, childFile, null, null));

					}

				}

				if (node != null) {

					// TODO findMember(..) using HashMap<name,childNode>

					List<VirtualTreeNode> children = node.members();

					for (VirtualTreeNode childNode : children) {

						if (name.equals(childNode.getName())) {

							childEntries.add(newEntry(null, null, null, childNode, null));

							break;

						}

					}

				}

			} else {

				if (name.equals(entry.getRuntimePath().segment(0))) { // still virtual

					childEntries.add(newEntry(entry.getRuntimePath().removeFirstSegments(1), resource, file, node, delta));

				}

			}

		}

		if (!isDelta || hasChanges(childEntries)) {

			IPath childRuntimePath = runtimePath.append(name);

			return newVirtualTreeNode(childRuntimePath, childEntries, isDelta);

		} else {

			return null;

		}

	}

	private static File findMember(File file, String name) {

		File[] children = file.listFiles();

		for (File child : children) {

			if (name.equals(child.getName())) {

				return child;

			}

		}

		return null;

	}

	private static boolean hasChanges(List<Entry> entries) {

		for (Entry entry : getResolvedEntries(entries)) {

			if (entry.getResourceDelta() != null) {

				return true;

			}

		}

		return false;

	}

	private static List<Entry> getResolvedEntries(List<Entry> entries) {

		ArrayList<Entry> result = new ArrayList<Entry>();

		for (Entry entry : entries) {

			if (entry.getRuntimePath() == null) {

				if (entry.getNode() != null) {

					result.addAll(entry.getNode().getResolvedEntries());

				} else {

					result.add(entry);

				}

			}

		}

		return result;

	}

	/**

	 * Hook that allows subclasses manipulate child nodes. Subclasses 

	 * implementation can return <code>null</code>. 

	 */

	public VirtualTreeNode newVirtualTreeNode(IPath runtimePath, List<Entry> entries, boolean isDelta) {

		return new VirtualTreeNode(runtimePath, entries, isDelta);

	}

	public IPath getRuntimePath() {

		return runtimePath;

	}

	/**

	 * Resolves nested virtual tree nodes into simple entries.

	 * 

	 * @return List<Entry> list of simple entries

	 */

	public List<Entry> getResolvedEntries() {

		return getResolvedEntries(entries);

	}

	public List<Entry> getRawEntries() {

		return entries;

	}

	protected static IResourceDelta findMember(IResourceDelta delta, IPath fullPath) {

		IPath deltaPath = delta.getResource().getFullPath();

		if (!deltaPath.isPrefixOf(fullPath)) return null;

		IPath relativePath = fullPath.removeFirstSegments(deltaPath.segmentCount());

		return delta.findMember(relativePath);

	}

	public int getKind() {

		boolean unchanged = false, added = false, removed = false, changed = false;

		for (Entry entry : getResolvedEntries()) {

			if (entry.getRuntimePath() == null) {

				IResourceDelta delta = entry.getResourceDelta();

				if (delta == null) {

					unchanged = true;

					continue;

				}

				switch (delta.getKind()) {

				case IResourceDelta.ADDED: added = true; break;

				case IResourceDelta.REMOVED: removed = true; break;

				case IResourceDelta.CHANGED: changed = true; break;

				}

			}

		}

		if (changed) return IResourceDelta.CHANGED;

		if (unchanged) {

			return (added || removed)? IResourceDelta.CHANGED: IResourceDelta.NO_CHANGE;

		} else {

			if (added && !removed) return IResourceDelta.ADDED;

			if (removed && !added) return IResourceDelta.REMOVED;

			return IResourceDelta.CHANGED;

		}

	}

	public String toString() {

		List<Entry> entries = getResolvedEntries();

		StringBuilder result = new StringBuilder();

		if (isDelta) {

			switch (getKind()) {

			case IResourceDelta.CHANGED: result.append("CHANGED"); break;

			case IResourceDelta.ADDED: result.append("ADDED"); break;

			case IResourceDelta.REMOVED: result.append("REMOVED"); break;

			case IResourceDelta.NO_CHANGE: result.append("NO_CHANGE"); break;

			default: result.append("????");

			}

			result.append(" ");

		}

		result.append(runtimePath).append(" -> [");

		boolean first = true;

		for(Entry entry : entries) {

			if (entry.getRuntimePath() == null) {

				if (!first) result.append(", ");

				if (entry.getResource() != null) {

					result.append(entry.getResource().toString());

				}

				if (entry.getFile() != null) {

					result.append(entry.getFile().isDirectory()? 'F': 'L');

					result.append(entry.getFile().toURI().getPath());

				}

				first = false;

			}

		}

		result.append("]");

		return result.toString();

	}

	public boolean isFolder() {

		List<Entry> resolvedEntries = getResolvedEntries();

		if (resolvedEntries.size() == 0) return true;

		Entry entry = resolvedEntries.get(0);

		return (entry.getResource() != null && entry.getResource() instanceof IContainer)

			|| (entry.getFile() != null && entry.getFile().isDirectory())

			|| (entry.getNode() != null && entry.getNode().isFolder());

	}

	public VirtualTreeNode getVirtualTreeDelta(IResourceDelta delta) {

		List<Entry> result = new ArrayList<Entry>();

		for (Entry entry : entries) {

			IResource resource = entry.getResource();

			VirtualTreeNode node = entry.getNode();

			IPath runtimePath = entry.getRuntimePath();

			if (runtimePath != null && runtimePath.segmentCount() == 0) runtimePath = null;

			if (resource != null) {

				result.add(new Entry(runtimePath, resource, null, null, findMember(delta, resource.getFullPath())));

			} else {

				result.add(new Entry(runtimePath, null, null, node.getVirtualTreeDelta(delta), null));

			}

		}

		return newVirtualTreeNode(Path.ROOT, result, true);

	}

}

#Sat Aug 19 23:14:33 EDT 2006

eclipse.preferences.version=1

internal.default.compliance=default