[jboss-cvs] jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal ...
Marshall Culpepper
mculpepper at jboss.com
Mon Nov 6 16:35:28 EST 2006
User: mculpepper
Date: 06/11/06 16:35:28
Added: core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal
PackageImpl.java PackageFileSetImpl.java
PackagesModel.java PackageNodeImpl.java
PackageBuildDelegate.java PackageFolderImpl.java
Log:
initial commit of the new "packages" tooling core plugin
Revision Changes Path
1.1 date: 2006/11/06 21:35:28; author: mculpepper; state: Exp;jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageImpl.java
Index: PackageImpl.java
===================================================================
/*
* JBoss, a division of Red Hat
* Copyright 2006, Red Hat Middleware, LLC, and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.ide.eclipse.packages.core.model.internal;
import java.io.IOException;
import java.util.jar.Manifest;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.jboss.ide.eclipse.packages.core.model.IPackage;
import org.jboss.ide.eclipse.packages.core.model.IPackageFileSet;
import org.jboss.ide.eclipse.packages.core.model.IPackageFolder;
import org.jboss.ide.eclipse.packages.core.model.IPackageNode;
import org.jboss.ide.eclipse.packages.core.model.IPackageNodeWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.IPackageWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackage;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackages;
/**
* A Package.
*
* @author <a href="marshall at jboss.org">Marshall Culpepper</a>
* @version $Revision: 1.1 $
*/
public class PackageImpl extends PackageNodeImpl implements IPackage, IPackageWorkingCopy {
private XbPackage packageDelegate;
private PackageImpl original;
public PackageImpl(IProject project, XbPackage delegate)
{
super(project, delegate);
this.packageDelegate = delegate;
}
public int getNodeType() {
return TYPE_PACKAGE;
}
public boolean isDestinationInWorkspace() {
return packageDelegate.isInWorkspace();
}
public IContainer getDestinationContainer() {
if (!isDestinationInWorkspace()) return null;
if (packageDelegate.getToDir() == null || packageDelegate.getToDir().equals("."))
return project;
return ResourcesPlugin.getWorkspace().getRoot().getContainerForLocation(new Path(packageDelegate.getToDir()));
}
public IPath getDestinationFolder () {
if (isDestinationInWorkspace()) return null;
String path = packageDelegate.getToDir();
if (path == null) return null;
return new Path(path);
}
public IPackageFileSet[] getFileSets() {
IPackageNode nodes[] = getChildren(TYPE_PACKAGE_FILESET);
IPackageFileSet filesets[] = new IPackageFileSet[nodes.length];
System.arraycopy(nodes, 0, filesets, 0, nodes.length);
return filesets;
}
public IPackageFolder[] getFolders() {
IPackageNode nodes[] = getChildren(TYPE_PACKAGE_FOLDER);
IPackageFolder folders[] = new IPackageFolder[nodes.length];
System.arraycopy(nodes, 0, folders, 0, nodes.length);
return folders;
}
public String getName() {
return packageDelegate.getName();
}
public IPackage[] getPackages() {
IPackageNode nodes[] = getChildren(TYPE_PACKAGE);
IPackage pkgs[] = new IPackage[nodes.length];
System.arraycopy(nodes, 0, pkgs, 0, nodes.length);
return pkgs;
}
public String getPackageType() {
return packageDelegate.getPackageType();
}
public IFile getPackageFile() {
if (isDestinationInWorkspace()) {
return getDestinationContainer().getFile(new Path(getName()));
} else return null;
}
public boolean isExploded() {
return packageDelegate.isExploded();
}
public boolean isReference() {
return (packageDelegate.getRef() != null
&& packageDelegate.getRef().length() > 0);
}
public boolean isTopLevel() {
return packageDelegate.getParent() instanceof XbPackages;
}
public Manifest getManifest() {
if (!hasManifest()) return null;
IFile manifestFile = getProject().getFile(packageDelegate.getManifest());
try {
return new Manifest(manifestFile.getContents());
} catch (IOException e) {
e.printStackTrace();
} catch (CoreException e) {
e.printStackTrace();
}
return null;
}
public boolean hasManifest() {
return packageDelegate.getManifest() != null;
}
public IPackageNodeWorkingCopy createWorkingCopy() {
return createPackageWorkingCopy();
}
public IPackageWorkingCopy createPackageWorkingCopy() {
PackageImpl copy = new PackageImpl(project, new XbPackage(packageDelegate));
copy.original = this;
return copy;
}
public IPackageNode save() {
return savePackage();
}
public IPackage savePackage() {
PackagesModel.instance().saveAndRegister(this, original);
saveChildren();
original = null;
return this;
}
public void addFileSet(IPackageFileSet fileset) {
addChild(fileset);
}
public void addFolder(IPackageFolder folder) {
addChild(folder);
}
public void addPackage(IPackage pkg) {
addChild(pkg);
}
public void setDestinationFolder(IPath path) {
packageDelegate.setInWorkspace(false);
packageDelegate.setToDir(path.toString());
PackagesModel.instance().fireNodeChanged(this);
}
public void setDestinationContainer(IContainer container) {
packageDelegate.setInWorkspace(true);
if (!container.equals(getProject()))
{
packageDelegate.setToDir(container.getFullPath().toString());
PackagesModel.instance().fireNodeChanged(this);
}
}
public void setExploded(boolean exploded) {
packageDelegate.setExploded(exploded);
PackagesModel.instance().fireNodeChanged(this);
}
public void setManifest(IFile manifestFile) {
packageDelegate.setManifest(manifestFile.getProjectRelativePath().toString());
PackagesModel.instance().fireNodeChanged(this);
}
public void setName(String name) {
packageDelegate.setName(name);
PackagesModel.instance().fireNodeChanged(this);
}
public void setPackageType(String type) {
packageDelegate.setPackageType(type);
PackagesModel.instance().fireNodeChanged(this);
}
public IPackageNode getOriginal() {
return getOriginalPackage();
}
public IPackage getOriginalPackage() {
return original;
}
public IPath getPackageRelativePath() {
if (getParent() == null) return null;
String path = new String(getName());
IPackageNode parent = getParent(), save = null;
while (true) {
if (parent.getNodeType() == IPackageNode.TYPE_PACKAGE)
path = ((IPackage)parent).getName() + "/" + path;
else
path = ((IPackageFolder)parent).getName() + "/" + path;
save = parent;
parent = parent.getParent();
if (parent == null) {
parent = save;
break;
}
}
return new Path(path);
}
public String toString() {
return getName();
}
}
1.1 date: 2006/11/06 21:35:28; author: mculpepper; state: Exp;jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageFileSetImpl.java
Index: PackageFileSetImpl.java
===================================================================
/*
* JBoss, a division of Red Hat
* Copyright 2006, Red Hat Middleware, LLC, and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.ide.eclipse.packages.core.model.internal;
import org.apache.tools.ant.DirectoryScanner;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.jboss.ide.eclipse.packages.core.model.IPackageFileSet;
import org.jboss.ide.eclipse.packages.core.model.IPackageFileSetWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.IPackageNode;
import org.jboss.ide.eclipse.packages.core.model.IPackageNodeWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.PackagesCore;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbFileSet;
/**
* A PackageFileSetImpl.
*
* @author <a href="marshall at jboss.org">Marshall Culpepper</a>
* @version $Revision: 1.1 $
*/
public class PackageFileSetImpl extends PackageNodeImpl implements
IPackageFileSet, IPackageFileSetWorkingCopy {
private XbFileSet filesetDelegate;
private PackageFileSetImpl original;
public PackageFileSetImpl (IProject project, XbFileSet delegate)
{
super(project, delegate);
this.filesetDelegate = delegate;
}
public IFile[] findMatchingFiles (DirectoryScanner scanner)
{
if (!isInWorkspace()) return new IFile[0];
if (isSingleFile())
return new IFile[] { getFile() };
else
return PackagesCore.findMatchingFiles(scanner, getSourceContainer(), getIncludesPattern(), getExcludesPattern());
}
public IFile[] findMatchingFiles() {
DirectoryScanner scanner = createDirectoryScanner(true);
return findMatchingFiles(scanner);
}
public IPath[] findMatchingPaths ()
{
DirectoryScanner scanner = createDirectoryScanner(true);
return findMatchingPaths(scanner);
}
public IPath[] findMatchingPaths (DirectoryScanner scanner)
{
if (isInWorkspace()) return new IPath[0];
if (isSingleFile())
return new IPath[] { getFilePath() };
else
return PackagesCore.findMatchingPaths(scanner, getSourceFolder(), getIncludesPattern(), getExcludesPattern());
}
public String getDestinationFilename() {
return filesetDelegate.getToFile();
}
public String getExcludesPattern() {
return filesetDelegate.getExcludes();
}
public boolean isInWorkspace() {
return filesetDelegate.isInWorkspace();
}
public IFile getFile() {
if (!isInWorkspace()) return null;
return getSourceProject().getFile(filesetDelegate.getFile());
}
public IPath getFilePath() {
if (isInWorkspace()) return null;
return new Path(filesetDelegate.getFile());
}
public String getIncludesPattern() {
return filesetDelegate.getIncludes();
}
public IContainer getSourceContainer() {
if (!isInWorkspace())
return null;
if (filesetDelegate.getDir() == null || filesetDelegate.getDir().equals(".") || filesetDelegate.getDir().equals(""))
return getSourceProject();
return getSourceProject().getFolder(filesetDelegate.getDir());
}
public IPath getSourceFolder() {
if (isInWorkspace())
return null;
String path = filesetDelegate.getDir();
if (path == null) return null;
return new Path(path);
}
public IProject getSourceProject() {
String projectName = filesetDelegate.getProject();
if (projectName == null || projectName.length() == 0)
return project;
else
return ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
}
public boolean isSingleFile() {
return filesetDelegate.getFile() != null;
}
public boolean matchesFile(DirectoryScanner scanner, IFile file)
{
if (!isInWorkspace()) return false;
String files[] = scanner.getIncludedFiles();
for (int i = 0; i < files.length; i++)
{
if (getSourceContainer().getFile(new Path(files[i])).equals(file))
{
return true;
}
}
return false;
}
public boolean matchesPath(DirectoryScanner scanner, IPath path)
{
if (isInWorkspace()) return false;
String paths[] = scanner.getIncludedFiles();
for (int i = 0; i < paths.length; i++)
{
if (getSourceFolder().append(paths[i]).equals(path))
{
return true;
}
}
return false;
}
public boolean matchesFile(IFile file) {
DirectoryScanner scanner = createDirectoryScanner(true);
return matchesFile(scanner, file);
}
public boolean matchesPath(IPath path) {
DirectoryScanner scanner = createDirectoryScanner(true);
return matchesPath(scanner, path);
}
public DirectoryScanner createDirectoryScanner(boolean scan) {
if (isInWorkspace())
{
return PackagesModel.createDirectoryScanner(
getSourceContainer(), getIncludesPattern(), getExcludesPattern(), scan);
} else {
return PackagesModel.createDirectoryScanner(
getSourceFolder(), getIncludesPattern(), getExcludesPattern(), scan);
}
}
public int getNodeType() {
return TYPE_PACKAGE_FILESET;
}
public void setExcludesPattern(String excludes) {
filesetDelegate.setExcludes(excludes);
PackagesModel.instance().fireNodeChanged(this);
}
public void setIncludesPattern(String includes) {
filesetDelegate.setIncludes(includes);
PackagesModel.instance().fireNodeChanged(this);
}
public void setSingleFile(IFile file, String destinationFilename) {
Assert.isNotNull(file);
filesetDelegate.setFile(file.getProjectRelativePath().toString());
filesetDelegate.setInWorkspace(true);
if (destinationFilename != null) {
filesetDelegate.setToFile(destinationFilename);
}
PackagesModel.instance().fireNodeChanged(this);
}
public void setSingleFile(IPath path, String destinationFilename) {
Assert.isNotNull(path);
filesetDelegate.setFile(path.toString());
filesetDelegate.setInWorkspace(false);
if (destinationFilename != null)
{
if (destinationFilename != null) {
filesetDelegate.setToFile(destinationFilename);
}
}
PackagesModel.instance().fireNodeChanged(this);
}
public void setInWorkspace(boolean isInWorkspace) {
filesetDelegate.setInWorkspace(isInWorkspace);
PackagesModel.instance().fireNodeChanged(this);
}
public void setSingleFile(IFile file) {
setSingleFile(file, null);
}
public void setSingleFile(IPath path) {
setSingleFile(path, null);
}
public void setSourceContainer(IContainer container) {
Assert.isNotNull(container);
filesetDelegate.setDir(container.getProjectRelativePath().toString());
filesetDelegate.setInWorkspace(true);
PackagesModel.instance().fireNodeChanged(this);
}
public void setSourceFolder (IPath path) {
Assert.isNotNull(path);
filesetDelegate.setDir(path.toString());
filesetDelegate.setInWorkspace(false);
PackagesModel.instance().fireNodeChanged(this);
}
public void setSourceProject(IProject project) {
Assert.isNotNull(project);
filesetDelegate.setProject(project.getName());
PackagesModel.instance().fireNodeChanged(this);
}
public IPackageNodeWorkingCopy createWorkingCopy() {
return createFileSetWorkingCopy();
}
public IPackageFileSetWorkingCopy createFileSetWorkingCopy() {
PackageFileSetImpl copy = new PackageFileSetImpl(project, new XbFileSet(filesetDelegate));
copy.original = this;
return copy;
}
public IPackageNode save() {
return saveFileSet();
}
public IPackageFileSet saveFileSet() {
PackagesModel.instance().saveAndRegister(this, original);
saveChildren();
original = null;
return this;
}
public IPackageNode getOriginal() {
return getOriginalFileSet();
}
public IPackageFileSet getOriginalFileSet() {
return original;
}
public String toString() {
String includes = filesetDelegate.getIncludes();
if (includes == null) includes = "";
return filesetDelegate.getDir() + " : " + includes;
}
}
1.1 date: 2006/11/06 21:35:28; author: mculpepper; state: Exp;jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackagesModel.java
Index: PackagesModel.java
===================================================================
/*
* JBoss, a division of Red Hat
* Copyright 2006, Red Hat Middleware, LLC, and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.ide.eclipse.packages.core.model.internal;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import org.apache.tools.ant.DirectoryScanner;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.jboss.ide.eclipse.core.util.ProjectUtil;
import org.jboss.ide.eclipse.packages.core.model.IPackage;
import org.jboss.ide.eclipse.packages.core.model.IPackageFileSetWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.IPackageFolderWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.IPackageNode;
import org.jboss.ide.eclipse.packages.core.model.IPackageWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.IPackagesBuildListener;
import org.jboss.ide.eclipse.packages.core.model.IPackagesModelListener;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XMLBinding;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbFileSet;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbFolder;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackage;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackageNode;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackages;
import org.jboss.ide.eclipse.packages.core.project.PackagesNature;
public class PackagesModel {
private static PackagesModel _instance;
public static final String PROJECT_PACKAGES_FILE = ".packages";
private Hashtable modelBridge;
private Hashtable projectPackages;
private Hashtable xbPackages;
private ArrayList buildListeners;
private ArrayList modelListeners;
private Hashtable deferredEvents;
private PackagesModel ()
{
modelBridge = new Hashtable();
projectPackages = new Hashtable();
xbPackages = new Hashtable();
buildListeners = new ArrayList();
modelListeners = new ArrayList();
deferredEvents = new Hashtable();
}
public static PackagesModel instance ()
{
if (_instance == null)
_instance = new PackagesModel();
return _instance;
}
public void registerProject(IProject project, IProgressMonitor monitor)
{
monitor.beginTask("Loading configuration...", XMLBinding.NUM_UNMARSHAL_MONITOR_STEPS + 2);
IFile packagesFile = project.getFile(PROJECT_PACKAGES_FILE);
if (packagesFile.exists())
{
try {
if (!project.hasNature(PackagesNature.NATURE_ID))
ProjectUtil.addProjectNature(project, PackagesNature.NATURE_ID);
XbPackages packages = XMLBinding.unmarshal(packagesFile.getContents(), monitor);
monitor.worked(1);
xbPackages.put(project, packages);
createPackageNodeImpl(project, packages);
monitor.worked(1);
} catch (CoreException e) {
e.printStackTrace();
}
}
}
public IPackageWorkingCopy createPackage(IProject project)
{
Assert.isNotNull(project);
return new PackageImpl(project, new XbPackage());
}
public IPackageFolderWorkingCopy createPackageFolder(IProject project) {
Assert.isNotNull(project);
return new PackageFolderImpl(project, new XbFolder());
}
public IPackageFileSetWorkingCopy createPackageFileSet(IProject project) {
Assert.isNotNull(project);
return new PackageFileSetImpl(project, new XbFileSet());
}
public void removePackage(IPackage pkg) {
if (projectPackages.containsKey(pkg.getProject()))
{
if (getProjectPackages(pkg.getProject()).contains(pkg))
getProjectPackages(pkg.getProject()).remove(pkg);
}
if (modelBridge.containsKey(pkg))
{
modelBridge.remove(pkg);
}
if (xbPackages.containsKey(pkg.getProject()))
{
PackageImpl packageImpl = (PackageImpl) pkg;
XbPackages packages = getXbPackages(pkg.getProject());
packages.removeChild(packageImpl.getNodeDelegate());
}
}
public XbPackages getXbPackages(IProject project)
{
return (XbPackages) xbPackages.get(project);
}
public List getProjectPackages (IProject project)
{
return (List)projectPackages.get(project);
}
public void addPackagesModelListener (IPackagesModelListener listener)
{
modelListeners.add(listener);
}
public void removePackagesModelListener (IPackagesModelListener listener)
{
if (modelListeners.contains(listener))
modelListeners.remove(listener);
}
public void addPackagesBuildListener (IPackagesBuildListener listener)
{
buildListeners.add(listener);
}
public void removePackagesBuildListener (IPackagesBuildListener listener)
{
if (buildListeners.contains(listener))
buildListeners.remove(listener);
}
protected List getBuildListeners ()
{
return buildListeners;
}
public static DirectoryScanner createDirectoryScanner (IPath filesystemFolder, String include, String excludes)
{
return createDirectoryScanner(filesystemFolder, include, excludes, true);
}
public static DirectoryScanner createDirectoryScanner (IContainer srcFolder, String include, String excludes)
{
return createDirectoryScanner(srcFolder, include, excludes, true);
}
public static DirectoryScanner createDirectoryScanner (IPath filesystemFolder, String includes, String excludes, boolean scan)
{
if (includes == null) includes = "";
if (excludes == null) excludes = "";
DirectoryScanner scanner = new DirectoryScanner();
String excludesList[] = excludes.split(" ?, ?");
String includesList[] = includes.split(" ?, ?");
File basedir = filesystemFolder.toFile();
scanner.setBasedir(basedir);
scanner.setExcludes(excludesList);
scanner.setIncludes(includesList);
if (scan)
scanner.scan();
return scanner;
}
public static DirectoryScanner createDirectoryScanner (IContainer srcFolder, String includes, String excludes, boolean scan)
{
if (includes == null) includes = "";
if (excludes == null) excludes = "";
DirectoryScanner scanner = new DirectoryScanner();
String excludesList[] = excludes.split(" ?, ?");
String includesList[] = includes.split(" ?, ?");
File basedir = srcFolder.getLocation().toFile();
if (srcFolder.getRawLocation() != null)
basedir = srcFolder.getRawLocation().toFile();
scanner.setBasedir(basedir);
scanner.setExcludes(excludesList);
scanner.setIncludes(includesList);
if (scan)
scanner.scan();
return scanner;
}
protected void saveAndRegister (PackageNodeImpl node, PackageNodeImpl original)
{
XbPackageNode parent = null;
if (original != null)
{
unregisterPackageNode(original, original.getNodeDelegate());
parent = original.getNodeDelegate().getParent();
if (parent != null)
parent.removeChild(original.getNodeDelegate());
if (original.getNodeType() == IPackageNode.TYPE_PACKAGE)
{
IPackage pkg = (IPackage) original;
removePackage(pkg);
}
original = null;
}
if (parent != null)
{
parent.addChild(node.getNodeDelegate());
}
else if (node.getNodeType() == IPackageNode.TYPE_PACKAGE)
{
XbPackages packages = getXbPackages(node.getProject());
if (packages == null) {
packages = new XbPackages();
xbPackages.put(node.getProject(), packages);
}
if (packages.getChildren(XbPackage.class) == null || !packages.getChildren(XbPackage.class).contains(node.getNodeDelegate()))
{
packages.addChild(node.getNodeDelegate());
}
}
registerPackageNode(node, node.getNodeDelegate());
saveModel(node.getProject());
if (deferredEvents.containsKey(node))
{
ArrayList events = (ArrayList) deferredEvents.get(node);
for (Iterator iter = events.iterator(); iter.hasNext(); )
{
Runnable runnable = (Runnable) iter.next();
runnable.run();
}
}
}
protected void saveModel (IProject project)
{
try {
IProgressMonitor nullMonitor = new NullProgressMonitor();
ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
OutputStreamWriter writer = new OutputStreamWriter(bytesOut);
XMLBinding.marshal(PackagesModel.instance().getXbPackages(project), writer, nullMonitor);
writer.close();
ByteArrayInputStream bytesIn = new ByteArrayInputStream(bytesOut.toByteArray());
IFile packagesFile = project.getFile(PackagesModel.PROJECT_PACKAGES_FILE);
if (!packagesFile.exists())
packagesFile.create(bytesIn, true, nullMonitor);
else
packagesFile.setContents(bytesIn, true, true, nullMonitor);
bytesIn.close();
bytesOut.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (CoreException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
protected PackageNodeImpl createPackageNodeImpl (IProject project, XbPackageNode node)
{
PackageNodeImpl nodeImpl = null;
if (node instanceof XbPackage)
{
nodeImpl = new PackageImpl(project, (XbPackage)node);
}
else if (node instanceof XbFolder)
{
nodeImpl = new PackageFolderImpl(project, (XbFolder)node);
}
else if (node instanceof XbFileSet)
{
nodeImpl = new PackageFileSetImpl(project, (XbFileSet)node);
}
for (Iterator iter = node.getAllChildren().iterator(); iter.hasNext(); )
{
XbPackageNode child = (XbPackageNode) iter.next();
// we don't need to do anything with child node impl's as they will
// be retrieved via lookup from the node delegates
createPackageNodeImpl(project, child);
}
if (nodeImpl != null)
{
registerPackageNode(nodeImpl, node);
}
return nodeImpl;
}
protected void fireNodeAdded (final IPackageNode added)
{
fireEventMaybeDeferred(added, new Runnable() {
public void run() {
for (Iterator iter = modelListeners.iterator(); iter.hasNext(); )
{
IPackagesModelListener listener = (IPackagesModelListener) iter.next();
listener.packageNodeAdded(added);
}
}
});
}
protected void fireNodeRemoved (final IPackageNode removed)
{
fireEventMaybeDeferred(removed, new Runnable() {
public void run() {
for (Iterator iter = modelListeners.iterator(); iter.hasNext(); )
{
IPackagesModelListener listener = (IPackagesModelListener) iter.next();
listener.packageNodeRemoved(removed);
}
}
});
}
protected void fireNodeChanged (final IPackageNode changed)
{
fireEventMaybeDeferred(changed, new Runnable() {
public void run() {
for (Iterator iter = modelListeners.iterator(); iter.hasNext(); )
{
IPackagesModelListener listener = (IPackagesModelListener) iter.next();
listener.packageNodeChanged(changed);
}
}
});
}
protected void fireEventMaybeDeferred (IPackageNode source, Runnable runnable)
{
PackageNodeImpl nodeImpl = (PackageNodeImpl) source;
if (nodeImpl.isWorkingCopy())
{
if (!deferredEvents.containsKey(source))
{
deferredEvents.put(source, new ArrayList());
}
((ArrayList)deferredEvents.get(source)).add(runnable);
}
else {
runnable.run();
}
}
protected void registerPackageNode(PackageNodeImpl nodeImpl, XbPackageNode node)
{
if (!modelBridge.containsKey(nodeImpl))
{
modelBridge.put(nodeImpl, node);
if (nodeImpl instanceof IPackage)
{
IPackage pkg = (IPackage) nodeImpl;
if (pkg.isTopLevel()) {
if (!projectPackages.containsKey(pkg.getProject()))
{
projectPackages.put(pkg.getProject(), new ArrayList());
}
getProjectPackages(pkg.getProject()).add(pkg);
}
}
fireNodeAdded(nodeImpl);
}
}
protected void unregisterPackageNode(PackageNodeImpl nodeImpl, XbPackageNode node) {
if (modelBridge.containsKey(nodeImpl))
{
modelBridge.remove(nodeImpl);
if (nodeImpl instanceof IPackage)
{
IPackage pkg = (IPackage) nodeImpl;
if (pkg.isTopLevel()) {
if (projectPackages.containsKey(pkg.getProject()))
{
List pkgs = getProjectPackages(pkg.getProject());
if (pkgs.contains(pkg))
{
pkgs.remove(pkg);
}
}
}
}
fireNodeRemoved(nodeImpl);
}
}
protected PackageNodeImpl getPackageNodeImpl(XbPackageNode node)
{
for (Iterator iter = modelBridge.keySet().iterator(); iter.hasNext(); )
{
PackageNodeImpl nodeImpl = (PackageNodeImpl)iter.next();
if (modelBridge.get(nodeImpl).equals(node))
{
return nodeImpl;
}
}
return null;
}
protected XbPackageNode getPackageNode(PackageNodeImpl nodeImpl)
{
return (XbPackageNode) modelBridge.get(nodeImpl);
}
}
1.1 date: 2006/11/06 21:35:28; author: mculpepper; state: Exp;jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageNodeImpl.java
Index: PackageNodeImpl.java
===================================================================
/*
* JBoss, a division of Red Hat
* Copyright 2006, Red Hat Middleware, LLC, and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.ide.eclipse.packages.core.model.internal;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.Assert;
import org.jboss.ide.eclipse.packages.core.model.IPackageNode;
import org.jboss.ide.eclipse.packages.core.model.IPackageNodeVisitor;
import org.jboss.ide.eclipse.packages.core.model.IPackageNodeWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbFileSet;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbFolder;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackage;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackageNode;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackageNodeWithProperties;
public abstract class PackageNodeImpl implements IPackageNode, IPackageNodeWorkingCopy {
protected XbPackageNodeWithProperties nodeDelegate;
protected IProject project;
protected ArrayList childrenToRegister, childrenToUnregister;
protected static int nodeTypeToIntType (Class type)
{
if (XbPackage.class.equals(type)) return TYPE_PACKAGE;
else if (XbFileSet.class.equals(type)) return TYPE_PACKAGE_FILESET;
else if (XbFolder.class.equals(type)) return TYPE_PACKAGE_FOLDER;
return -1;
}
protected static Class intTypeToNodeType (int type)
{
switch (type) {
case TYPE_PACKAGE:
return XbPackage.class;
case TYPE_PACKAGE_FILESET:
return XbFileSet.class;
case TYPE_PACKAGE_FOLDER:
return XbFolder.class;
}
return null;
}
public PackageNodeImpl (IProject project, XbPackageNodeWithProperties delegate)
{
nodeDelegate = delegate;
this.project = project;
childrenToRegister = new ArrayList();
childrenToUnregister = new ArrayList();
}
public PackageNodeImpl ()
{
this(null, null);
}
public XbPackageNode getNodeDelegate()
{
return nodeDelegate;
}
private IPackageNode[] nodesToChildren (List nodes)
{
IPackageNode children[] = new IPackageNode[nodes.size()];
int i = 0;
for (Iterator iter = nodes.iterator(); iter.hasNext();)
{
XbPackageNode node = (XbPackageNode) iter.next();
children[i] = PackagesModel.instance().getPackageNodeImpl(node);
i++;
}
return children;
}
public IPackageNode[] getAllChildren ()
{
return nodesToChildren(nodeDelegate.getAllChildren());
}
public IPackageNode[] getChildren(int type) {
return nodesToChildren(nodeDelegate.getChildren(intTypeToNodeType(type)));
}
public boolean hasChildren () {
return nodeDelegate.hasChildren();
}
public boolean hasChild (IPackageNode child)
{
PackageNodeImpl childImpl = (PackageNodeImpl)child;
return nodeDelegate.getAllChildren().contains(childImpl.nodeDelegate);
}
public IPackageNode getParent() {
XbPackageNode parent = nodeDelegate.getParent();
if (parent != null)
return PackagesModel.instance().getPackageNodeImpl(parent);
return null;
}
public IProject getProject() {
return project;
}
public String getProperty(String property) {
return getProperties().getProperty(property);
}
public void setProperty(String property, String value) {
getProperties().setProperty(property, value);
PackagesModel.instance().fireNodeChanged(this);
}
public Properties getProperties() {
return nodeDelegate.getProperties().getProperties();
}
public boolean accept(IPackageNodeVisitor visitor) {
return accept(visitor, false);
}
public boolean accept(IPackageNodeVisitor visitor, boolean depthFirst) {
IPackageNode children[] = getAllChildren();
boolean keepGoing = true;
if (!depthFirst)
keepGoing = visitor.visit(this);
if (keepGoing)
{
for (int i = 0; i < children.length; i++)
{
if (keepGoing) {
keepGoing = children[i].accept(visitor, depthFirst);
}
}
}
if (depthFirst && keepGoing)
keepGoing = visitor.visit(this);
return keepGoing;
}
public void addChild(IPackageNode node) {
PackageNodeImpl impl = (PackageNodeImpl) node;
nodeDelegate.addChild(impl.nodeDelegate);
childrenToRegister.add(node);
save();
}
public void removeChild(IPackageNode node) {
Assert.isNotNull(node);
PackageNodeImpl impl = (PackageNodeImpl) node;
if (nodeDelegate.getAllChildren().contains(impl.nodeDelegate)) {
nodeDelegate.removeChild(impl.nodeDelegate);
}
if (childrenToRegister.contains(node))
{
childrenToRegister.remove(node);
}
else {
childrenToUnregister.add(node);
}
save();
}
protected void saveChildren ()
{
for (Iterator iter = childrenToRegister.iterator(); iter.hasNext(); )
{
PackageNodeImpl node = (PackageNodeImpl) iter.next();
PackagesModel.instance().registerPackageNode(node, node.getNodeDelegate());
}
for (Iterator iter = childrenToUnregister.iterator(); iter.hasNext(); )
{
PackageNodeImpl node = (PackageNodeImpl) iter.next();
PackagesModel.instance().unregisterPackageNode(node, node.getNodeDelegate());
}
childrenToRegister.clear();
childrenToUnregister.clear();
}
public Object getAdapter(Class adapter) {
if (adapter.equals(IProject.class))
{
return getProject();
}
else return null;
}
public boolean isWorkingCopy ()
{
return getOriginal() != null;
}
}
1.1 date: 2006/11/06 21:35:28; author: mculpepper; state: Exp;jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageBuildDelegate.java
Index: PackageBuildDelegate.java
===================================================================
/*
* JBoss, a division of Red Hat
* Copyright 2006, Red Hat Middleware, LLC, and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.ide.eclipse.packages.core.model.internal;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import org.apache.tools.ant.DirectoryScanner;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.jboss.ide.eclipse.core.util.ProjectUtil;
import org.jboss.ide.eclipse.packages.core.Trace;
import org.jboss.ide.eclipse.packages.core.model.IPackage;
import org.jboss.ide.eclipse.packages.core.model.IPackageFileSet;
import org.jboss.ide.eclipse.packages.core.model.IPackageFolder;
import org.jboss.ide.eclipse.packages.core.model.IPackageNode;
import org.jboss.ide.eclipse.packages.core.model.IPackageNodeVisitor;
import org.jboss.ide.eclipse.packages.core.model.IPackagesBuildListener;
import org.jboss.ide.eclipse.packages.core.model.IPackagesModelListener;
import org.jboss.ide.eclipse.packages.core.model.PackagesCore;
import org.jboss.ide.eclipse.packages.core.project.PackagesBuilder;
import org.jboss.ide.eclipse.packages.core.util.PackagesExport;
import de.schlichtherle.io.ArchiveDetector;
import de.schlichtherle.io.ArchiveException;
import de.schlichtherle.io.File;
import de.schlichtherle.io.FileOutputStream;
public class PackageBuildDelegate implements IPackagesModelListener {
private ArrayList referencedProjects;
private Hashtable scannerCache;
private IPackage packages[];
private ArrayList nodesToUpdate, nodesToRemove;
private IProject project;
private IResourceDelta delta;
public PackageBuildDelegate (PackagesBuilder builder)
{
this(builder.getProject(), builder.getDelta(builder.getProject()));
}
public PackageBuildDelegate (IProject project)
{
this(project, null);
}
public PackageBuildDelegate (IProject project, IResourceDelta delta)
{
this.project = project;
this.delta = delta;
nodesToUpdate = new ArrayList();
nodesToRemove = new ArrayList();
PackagesModel.instance().addPackagesModelListener(this);
}
public void packageNodeAdded(IPackageNode added) {
nodesToUpdate.add(added);
}
public void packageNodeChanged(IPackageNode changed) {
nodesToUpdate.add(changed);
}
public void packageNodeRemoved(IPackageNode removed) {
nodesToRemove.add(removed);
}
private void fireStartedBuild (IProject project)
{
for (Iterator iter = PackagesModel.instance().getBuildListeners().iterator(); iter.hasNext(); )
((IPackagesBuildListener)iter.next()).startedBuild(project);
}
private void fireStartedBuildingPackage (IPackage pkg)
{
for (Iterator iter = PackagesModel.instance().getBuildListeners().iterator(); iter.hasNext(); )
((IPackagesBuildListener)iter.next()).startedBuildingPackage(pkg);
}
private void fireStartedCollectingFileSet (IPackageFileSet fileset)
{
for (Iterator iter = PackagesModel.instance().getBuildListeners().iterator(); iter.hasNext(); )
((IPackagesBuildListener)iter.next()).startedCollectingFileSet(fileset);
}
private void fireFinishedCollectingFileSet (IPackageFileSet fileset)
{
for (Iterator iter = PackagesModel.instance().getBuildListeners().iterator(); iter.hasNext(); )
((IPackagesBuildListener)iter.next()).finishedCollectingFileSet(fileset);
}
private void fireFinishedBuildingPackage (IPackage pkg)
{
for (Iterator iter = PackagesModel.instance().getBuildListeners().iterator(); iter.hasNext(); )
((IPackagesBuildListener)iter.next()).finishedBuildingPackage(pkg);
}
private void fireFinishedBuild (IProject project)
{
for (Iterator iter = PackagesModel.instance().getBuildListeners().iterator(); iter.hasNext(); )
((IPackagesBuildListener)iter.next()).finishedBuild(project);
}
private void createScannerCache ()
{
scannerCache = new Hashtable();
for (int i = 0; i < packages.length; i++)
{
final IPackage pkg = packages[i];
final Hashtable filesetCache = new Hashtable();
scannerCache.put(pkg, filesetCache);
pkg.accept(new IPackageNodeVisitor() {
public boolean visit(IPackageNode node) {
if (node.getNodeType() == IPackageNode.TYPE_PACKAGE_FILESET)
{
PackageFileSetImpl fileset = (PackageFileSetImpl) node;
filesetCache.put(fileset, fileset.createDirectoryScanner(true));
}
return true;
}
});
}
}
private IPackageFileSet findMatchingFileset (IFile file)
{
for (Iterator iter = scannerCache.keySet().iterator(); iter.hasNext(); )
{
IPackage pkg = (IPackage) iter.next();
Hashtable scanners = (Hashtable) scannerCache.get(pkg);
for (Iterator filesetIter = scanners.keySet().iterator(); filesetIter.hasNext(); )
{
PackageFileSetImpl fileset = (PackageFileSetImpl) filesetIter.next();
DirectoryScanner scanner = (DirectoryScanner) scanners.get(fileset);
if (fileset.matchesFile(scanner, file))
{
return fileset;
}
}
}
return null;
}
private void buildFileset (IPackageFileSet fileset, boolean checkStamps)
{
IPackage pkg = PackagesCore.getTopLevelPackage(fileset);
DirectoryScanner scanner = (DirectoryScanner) ((Hashtable)scannerCache.get(pkg)).get(fileset);
if (fileset.isInWorkspace())
{
fireStartedCollectingFileSet(fileset);
IFile matchingFiles[] = ((PackageFileSetImpl)fileset).findMatchingFiles(scanner);
fireFinishedCollectingFileSet(fileset);
for (int i = 0; i < matchingFiles.length; i++)
{
updateFile(matchingFiles[i], fileset, checkStamps);
}
} else {
fireStartedCollectingFileSet(fileset);
IPath matchingPaths[] = ((PackageFileSetImpl)fileset).findMatchingPaths(scanner);
fireFinishedCollectingFileSet(fileset);
for (int i = 0; i < matchingPaths.length; i++)
{
updatePath(matchingPaths[i], fileset, checkStamps);
}
}
}
private int buildSteps;
private int countBuildSteps (IPackage pkg)
{
buildSteps = 0;
pkg.accept(new IPackageNodeVisitor () {
public boolean visit (IPackageNode node) {
if (node.getNodeType() == IPackageNode.TYPE_PACKAGE_FILESET)
{
buildSteps++;
}
return true;
}
});
return buildSteps;
}
private void buildPackage (IPackage pkg, final IProgressMonitor monitor)
{
fireStartedBuildingPackage(pkg);
int steps = countBuildSteps(pkg);
monitor.beginTask("Building package \"" + pkg.getName() + "\"...", steps);
pkg.accept(new IPackageNodeVisitor () {
public boolean visit(IPackageNode node) {
if (node.getNodeType() == IPackageNode.TYPE_PACKAGE_FILESET)
{
buildFileset((IPackageFileSet)node, false);
monitor.worked(1);
}
return true;
}
});
IFile file = pkg.getPackageFile();
try {
file.refreshLocal(IResource.DEPTH_ONE, monitor);
} catch (CoreException e) {
Trace.trace(getClass(), e);
}
monitor.done();
fireFinishedBuildingPackage(pkg);
}
private void fullBuild(Map args, IProgressMonitor monitor)
{
for (int i = 0; i < packages.length; i++)
{
buildPackage(packages[i], monitor);
}
}
private void cleanBuild(Map args, IProgressMonitor monitor)
{
monitor.beginTask("Cleaning packages...", packages.length);
for (int i = 0; i < packages.length; i++)
{
IFile packageFile = packages[i].getPackageFile();
if (packageFile.exists())
{
try {
packageFile.delete(true, monitor);
} catch (CoreException e) {
Trace.trace(getClass(), e);
}
}
monitor.worked(1);
}
monitor.done();
}
public void buildSinglePackage (IPackage pkg, IProgressMonitor monitor)
{
packages = new IPackage[] { pkg };
createScannerCache();
buildPackage(pkg, monitor);
scannerCache = null;
}
public IProject[] build(int kind, Map args, IProgressMonitor monitor)
throws CoreException {
referencedProjects = new ArrayList();
packages = PackagesCore.getProjectPackages(project, monitor);
monitor.beginTask("Finding referenced projects...", packages.length);
for (int i = 0; i < packages.length; i++)
{
referencedProjects.addAll(PackagesExport.findReferencedProjects(project, packages[i]));
monitor.worked(1);
}
monitor.done();
createScannerCache();
try {
if (kind == IncrementalProjectBuilder.INCREMENTAL_BUILD || kind == IncrementalProjectBuilder.AUTO_BUILD)
{
fireStartedBuild(project);
incrementalBuild(args, monitor);
fireFinishedBuild(project);
}
else if (kind == IncrementalProjectBuilder.CLEAN_BUILD)
{
cleanBuild(args, monitor);
}
else if (kind == IncrementalProjectBuilder.FULL_BUILD)
{
fireStartedBuild(project);
fullBuild(args, monitor);
fireFinishedBuild(project);
}
} finally {
try {
File.umount();
} catch (ArchiveException e) {
Trace.trace(getClass(), e);
}
}
scannerCache = null;
nodesToUpdate.clear();
nodesToRemove.clear();
return (IProject[])referencedProjects.toArray(new IProject[referencedProjects.size()]);
}
private Hashtable filesToCopy, filesToRemove;
private void incrementalBuild(Map args, final IProgressMonitor monitor)
{
filesToCopy = new Hashtable();
filesToRemove = new Hashtable();
for (Iterator iter = referencedProjects.iterator(); iter.hasNext(); )
{
final IProject project = (IProject) iter.next();
if (delta != null)
{
try {
delta.accept(new IResourceDeltaVisitor () {
public boolean visit(IResourceDelta delta) throws CoreException {
if (delta.getResource().getType() == IResource.FILE)
processFileDelta(project, delta, monitor);
return true;
}
});
} catch (CoreException e) {
Trace.trace(getClass(), e);
}
}
}
for (Iterator iter = filesToCopy.keySet().iterator(); iter.hasNext(); )
{
IFile file = (IFile)iter.next();
IPackageFileSet fileset = (IPackageFileSet) filesToCopy.get(file);
updateFile(file, fileset, false);
}
for (Iterator iter = filesToRemove.keySet().iterator(); iter.hasNext(); )
{
IFile file = (IFile)iter.next();
IPackageFileSet fileset = (IPackageFileSet) filesToRemove.get(file);
removeFile(file, fileset);
}
for (Iterator iter = nodesToUpdate.iterator(); iter.hasNext(); )
{
IPackageNode node = (IPackageNode) iter.next();
updateNode(node);
}
for (Iterator iter = nodesToRemove.iterator(); iter.hasNext(); )
{
IPackageNode node = (IPackageNode) iter.next();
removeNode(node);
}
filesToCopy.clear();
filesToRemove.clear();
}
private IPackage getPackageFromFile (IFile file)
{
for (int i = 0; i < packages.length; i++)
{
if (packages[i].getName().equals(file.getName()) && packages[i].getDestinationContainer().equals(file.getParent()))
{
return packages[i];
}
}
return null;
}
private void processFileDelta (IProject project, IResourceDelta delta, IProgressMonitor monitor)
{
IFile file = (IFile) delta.getResource();
IPackageFileSet fileset = findMatchingFileset(file);
IPackage pkg = getPackageFromFile(file);
if ((delta.getFlags() & IResourceDelta.REMOVED) > 0)
{
if (pkg != null)
{
buildPackage(pkg, monitor);
return;
}
}
if (fileset != null)
{
if ((delta.getFlags() & IResourceDelta.ADDED) > 0)
{
filesToCopy.put(file, fileset);
}
else if ((delta.getFlags() & IResourceDelta.CONTENT) > 0 || (delta.getFlags() & IResourceDelta.CHANGED) > 0)
{
filesToCopy.put(file, fileset);
}
else if ((delta.getFlags() & IResourceDelta.REMOVED) > 0)
{
filesToRemove.put(file, fileset);
}
}
}
private File createFilesetRoot (IPackageFileSet fileset)
{
ArrayList parents = new ArrayList();
IPackageNode parent = fileset.getParent();
while (parent != null)
{
parents.add(0, parent);
parent = parent.getParent();
}
IPackage topLevelPackage = PackagesCore.getTopLevelPackage(fileset);
File root = null;
if (topLevelPackage.isDestinationInWorkspace())
{
IPath projectPath = ProjectUtil.getProjectLocation(topLevelPackage.getProject());
IPath subPath = topLevelPackage.getDestinationContainer().getProjectRelativePath();
root = new File(projectPath.append(subPath).toFile());
} else {
root = new File(topLevelPackage.getDestinationFolder().toFile());
}
for (Iterator iter = parents.iterator(); iter.hasNext(); )
{
IPackageNode currentParent = (IPackageNode) iter.next();
if (currentParent.getNodeType() == IPackageNode.TYPE_PACKAGE) {
IPackage pkg = (IPackage)currentParent;
root = new File(root, pkg.getName(), pkg.isExploded() ? ArchiveDetector.NULL : ArchiveDetector.DEFAULT);
} else if (currentParent.getNodeType() == IPackageNode.TYPE_PACKAGE_FOLDER) {
IPackageFolder folder = (IPackageFolder)currentParent;
root = new File(root, folder.getName(), ArchiveDetector.NULL);
}
}
return root;
}
private File createFile (IPackageFileSet fileset, IPath subPath)
{
return new File(createFilesetRoot(fileset), subPath.toString(), ArchiveDetector.NULL);
}
private OutputStream createFileOutputStream (IPackageFileSet fileset, IPath subPath)
{
File root = createFilesetRoot(fileset);
root = new File(root, subPath.toString(), ArchiveDetector.NULL);
try {
return new FileOutputStream(root);
} catch (FileNotFoundException e) {
Trace.trace(getClass(), e);
}
return null;
}
// private IPath getNode333ParentPath (IPackageNode node)
// {
// IPackageNode parent = node.getParent();
// IPath parentPath = null;
// if (parent.getNodeType() == IPackageNode.TYPE_PACKAGE)
// {
// parentPath = ((IPackage)parent).getPackageRelativePath();
// }
// else if (parent.getNodeType() == IPackageNode.TYPE_PACKAGE_FOLDER)
// {
// parentPath = ((IPackageFolder)parent).getPackageRelativePath();
// }
//
// IPackage topLevelPackage = PackagesCore.getTopLevelPackage(node);
//
// IContainer destination = topLevelPackage.getDestinationContainer();
// IPath fullPath = destination.getProjectRelativePath();
// if (destination.equals(topLevelPackage.getProject()))
// {
// fullPath = ProjectUtil.getProjectLocation(topLevelPackage.getProject());
// }
//
// if (parentPath != null)
// fullPath = fullPath.append(parentPath);
//
// return fullPath;
// }
private IPath getFileDestinationPath (IFile file, IPackageFileSet fileset)
{
IPath filePath = file.getProjectRelativePath();
IPath copyTo = filePath.removeFirstSegments(fileset.getSourceContainer().getProjectRelativePath().segmentCount()).removeLastSegments(1);
copyTo = copyTo.append(file.getName());
copyTo = copyTo.setDevice(null);
return copyTo;
}
private IPath getPathDestinationPath (IPath path, IPackageFileSet fileset)
{
IPath copyTo = path.removeFirstSegments(fileset.getSourceFolder().segmentCount()).removeLastSegments(1);
copyTo = copyTo.append(path.lastSegment());
copyTo = copyTo.setDevice(null);
return copyTo;
}
private void updateFile(IFile file, IPackageFileSet fileset, boolean checkStamps)
{
IPath copyTo = getFileDestinationPath(file, fileset);
if (checkStamps)
{
File packageFile = createFile(fileset, copyTo);
long stamp = file.getModificationStamp();
if (stamp != IResource.NULL_STAMP && packageFile.exists() && stamp >= packageFile.lastModified())
{
return;
}
}
Trace.trace(getClass(), "copying " + file.getProjectRelativePath().toString() + " ...");
InputStream in = null;
OutputStream out = null;
// I'm using the fully qualified package name here to avoid confusion with java.io
try {
try {
in = file.getContents();
out = createFileOutputStream(fileset, copyTo);
File.cp(in, out);
} catch (FileNotFoundException e) {
Trace.trace(getClass(), e);
} catch (IOException e) {
Trace.trace(getClass(), e);
} catch (CoreException e) {
Trace.trace(getClass(), e);
}
} finally {
try {
if (in != null) {
Trace.trace(getClass(), "closing file contents inputstream", Trace.DEBUG_OPTION_STREAM_CLOSE);
in.close();
}
if (out != null) {
Trace.trace(getClass(), "closing package file outputstream", Trace.DEBUG_OPTION_STREAM_CLOSE);
out.close();
}
} catch (IOException e) {
Trace.trace(getClass(), e);
}
}
}
private void updatePath(IPath path, IPackageFileSet fileset, boolean checkStamps)
{
IPath copyTo = getPathDestinationPath(path, fileset);
if (checkStamps)
{
File packageFile = createFile(fileset, copyTo);
File externalFile = new File(path.toFile());
long stamp = externalFile.lastModified();
if (packageFile.exists() && stamp >= packageFile.lastModified())
{
return;
}
}
Trace.trace(getClass(), "copying " + path.toString() + " ...");
InputStream in = null;
OutputStream out = null;
try {
try {
in = new FileInputStream(path.toFile());
out = createFileOutputStream(fileset, copyTo);
File.cp(in, out);
} catch (FileNotFoundException e) {
Trace.trace(getClass(), e);
} catch (IOException e) {
Trace.trace(getClass(), e);
}
} finally {
try {
if (in != null) {
Trace.trace(getClass(), "closing file contents input stream", Trace.DEBUG_OPTION_STREAM_CLOSE);
in.close();
}
if (out != null) {
Trace.trace(getClass(), "closing package file outputstream", Trace.DEBUG_OPTION_STREAM_CLOSE);
out.close();
}
} catch (IOException e) {
Trace.trace(getClass(), e);
}
}
}
private void removeFile(IFile file, IPackageFileSet fileset)
{
File packagedFile = new File(getFileDestinationPath(file, fileset).toFile());
if (packagedFile.exists()) packagedFile.deleteAll();
}
private void removePath(IPath path, IPackageFileSet fileset)
{
File packagedFile = new File(getPathDestinationPath(path, fileset).toFile());
if (packagedFile.exists()) packagedFile.deleteAll();
}
private void updateNode (IPackageNode node)
{
if (node.getNodeType() == IPackageNode.TYPE_PACKAGE_FILESET)
{
buildFileset((IPackageFileSet)node, true);
}
else {
node.accept(new IPackageNodeVisitor () {
public boolean visit(IPackageNode node) {
if (node.getNodeType() == IPackageNode.TYPE_PACKAGE_FILESET)
{
buildFileset((IPackageFileSet)node, true);
}
return true;
}
});
}
}
private void removeNode (IPackageNode node)
{
NullProgressMonitor nullMonitor = new NullProgressMonitor();
if (node.getNodeType() == IPackageNode.TYPE_PACKAGE)
{
IPackage pkg = (IPackage) node;
if (pkg.isTopLevel())
{
IFile packageFile = pkg.getPackageFile();
try {
packageFile.delete(true, true, nullMonitor);
} catch (CoreException e) {
Trace.trace(getClass(), e);
}
}
else {
removeInnerPackage(pkg);
}
}
else if (node.getNodeType() == IPackageNode.TYPE_PACKAGE_FILESET)
{
removeFileset((IPackageFileSet) node);
}
else if (node.getNodeType() == IPackageNode.TYPE_PACKAGE_FOLDER)
{
removeFolder((IPackageFolder) node);
}
}
private void removeInnerPackage (IPackage pkg)
{
// IPath parentPath = getNodeParentPath(pkg);
// File file = new File(parentPath.toFile());
//
// if (file.exists()) file.deleteAll();
}
private void removeFileset (IPackageFileSet fileset)
{
IPackage pkg = PackagesCore.getTopLevelPackage(fileset);
DirectoryScanner scanner = (DirectoryScanner) ((Hashtable)scannerCache.get(pkg)).get(fileset);
if (fileset.isInWorkspace())
{
fireStartedCollectingFileSet(fileset);
IFile matchingFiles[] = ((PackageFileSetImpl)fileset).findMatchingFiles(scanner);
fireFinishedCollectingFileSet(fileset);
for (int i = 0; i < matchingFiles.length; i++)
{
removeFile(matchingFiles[i], fileset);
}
} else {
fireStartedCollectingFileSet(fileset);
IPath matchingPaths[] = ((PackageFileSetImpl)fileset).findMatchingPaths(scanner);
fireFinishedCollectingFileSet(fileset);
for (int i = 0; i < matchingPaths.length; i++)
{
removePath(matchingPaths[i], fileset);
}
}
}
private void removeFolder (IPackageFolder folder)
{
// IPath parentPath = getNodeParentPath(folder);
// File file = new File(parentPath.append(folder.getName()).toFile());
//
// if (file.exists()) file.deleteAll();
}
}
1.1 date: 2006/11/06 21:35:28; author: mculpepper; state: Exp;jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageFolderImpl.java
Index: PackageFolderImpl.java
===================================================================
/*
* JBoss, a division of Red Hat
* Copyright 2006, Red Hat Middleware, LLC, and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.ide.eclipse.packages.core.model.internal;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.jboss.ide.eclipse.packages.core.model.IPackage;
import org.jboss.ide.eclipse.packages.core.model.IPackageFileSet;
import org.jboss.ide.eclipse.packages.core.model.IPackageFolder;
import org.jboss.ide.eclipse.packages.core.model.IPackageFolderWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.IPackageNode;
import org.jboss.ide.eclipse.packages.core.model.IPackageNodeWorkingCopy;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbFolder;
/**
* A PackageFolderImpl.
*
* @author <a href="marshall at jboss.org">Marshall Culpepper</a>
* @version $Revision: 1.1 $
*/
public class PackageFolderImpl extends PackageNodeImpl implements
IPackageFolder, IPackageFolderWorkingCopy {
private XbFolder folderDelegate;
private PackageFolderImpl original;
public PackageFolderImpl(IProject project, XbFolder delegate)
{
super(project, delegate);
this.folderDelegate = delegate;
}
public String getName() {
return folderDelegate.getName();
}
public IPackageFileSet[] getFileSets() {
IPackageNode nodes[] = getChildren(TYPE_PACKAGE_FILESET);
IPackageFileSet filesets[] = new IPackageFileSet[nodes.length];
System.arraycopy(nodes, 0, filesets, 0, nodes.length);
return filesets;
}
public IPackageFolder[] getFolders() {
IPackageNode nodes[] = getChildren(TYPE_PACKAGE_FOLDER);
IPackageFolder folders[] = new IPackageFolder[nodes.length];
System.arraycopy(nodes, 0, folders, 0, nodes.length);
return folders;
}
public IPackage[] getPackages() {
IPackageNode nodes[] = getChildren(TYPE_PACKAGE);
IPackage pkgs[] = new IPackage[nodes.length];
System.arraycopy(nodes, 0, pkgs, 0, nodes.length);
return pkgs;
}
public int getNodeType() {
return TYPE_PACKAGE_FOLDER;
}
public void addFileSet(IPackageFileSet fileset) {
addChild(fileset);
}
public void addFolder(IPackageFolder folder) {
addChild(folder);
}
public void addPackage(IPackage pkg) {
addChild(pkg);
}
public void setName(String name) {
folderDelegate.setName(name);
PackagesModel.instance().fireNodeChanged(this);
}
public IPackageNodeWorkingCopy createWorkingCopy() {
return createFolderWorkingCopy();
}
public IPackageFolderWorkingCopy createFolderWorkingCopy() {
PackageFolderImpl copy = new PackageFolderImpl(project, new XbFolder(folderDelegate));
copy.original = this;
return copy;
}
public IPackageNode save() {
return saveFolder();
}
public IPackageFolder saveFolder() {
PackagesModel.instance().saveAndRegister(this, original);
saveChildren();
original = null;
return this;
}
public IPackageNode getOriginal() {
return getOriginalFolder();
}
public IPackageFolder getOriginalFolder() {
return original;
}
public IPath getPackageRelativePath() {
String path = new String(getName());
IPackageNode parent = getParent(), save = null;
while (true) {
if (parent.getNodeType() == IPackageNode.TYPE_PACKAGE)
path = ((IPackage)parent).getName() + "/" + path;
else
path = ((IPackageFolder)parent).getName() + "/" + path;
save = parent;
parent = parent.getParent();
if (parent == null) {
parent = save;
break;
}
}
return new Path(path);
}
public String toString() {
return "folder[" + getName() + "]";
}
}
More information about the jboss-cvs-commits
mailing list