[jboss-cvs] jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal ...
Robert Stryker
rob.stryker at jboss.com
Mon Apr 16 13:34:42 EDT 2007
User: rawb
Date: 07/04/16 13:34:42
Added: core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal
PackagesModelDeltaPreFactory.java
PackagesModel.java PackageNodeImpl.java
PackageModelNode.java PackageImpl.java
PackagesModelDeltaImpl.java PackageFolderImpl.java
PackageFileSetImpl.java
Log:
Complete rewrite of the the two plugins leading to a cleaner, leaner project.
Revision Changes Path
1.1 date: 2007/04/16 17:34:42; author: rawb; state: Exp;jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackagesModelDeltaPreFactory.java
Index: PackagesModelDeltaPreFactory.java
===================================================================
package org.jboss.ide.eclipse.packages.core.model.internal;
import java.util.HashMap;
import java.util.Iterator;
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.internal.PackagesModelDeltaImpl.NodeDelta;
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.XbPackageNodeWithProperties;
public class PackagesModelDeltaPreFactory {
// children get added later
public static PackageNodeImpl createNode(PackagesModelDeltaImpl parentDelta, PackageNodeImpl postChange,
HashMap attributeChanges, HashMap propertyChanges) {
switch(postChange.getNodeType()) {
case IPackageNode.TYPE_PACKAGE_FILESET:
XbFileSet fs = createFileset((PackageFileSetImpl)postChange, attributeChanges, propertyChanges);
return new DeltaFileset(fs, parentDelta);
case IPackageNode.TYPE_PACKAGE_FOLDER:
XbFolder folder = createFolder((PackageFolderImpl)postChange, attributeChanges, propertyChanges);
return new DeltaFolder(folder, parentDelta);
case IPackageNode.TYPE_PACKAGE:
XbPackage pack = createPackage((PackageImpl)postChange, attributeChanges, propertyChanges);
return new DeltaPackage(pack, parentDelta);
}
return null;
}
protected static XbFileSet createFileset(PackageFileSetImpl postChange,HashMap attributeChanges, HashMap propertyChanges ) {
XbFileSet fs = new XbFileSet((XbFileSet)postChange.nodeDelegate);
// fs.setDir("FILESET TEST CHANGE");
if( attributeChanges.containsKey(IPackageFileSet.INCLUDES_ATTRIBUTE))
fs.setIncludes(getBeforeString(attributeChanges, IPackageFileSet.INCLUDES_ATTRIBUTE));
if( attributeChanges.containsKey(IPackageFileSet.EXCLUDES_ATTRIBUTE))
fs.setExcludes(getBeforeString(attributeChanges, IPackageFileSet.EXCLUDES_ATTRIBUTE));
if( attributeChanges.containsKey(IPackageFileSet.SOURCE_PATH_ATTRIBUTE))
fs.setDir(getBeforeString(attributeChanges, IPackageFileSet.SOURCE_PATH_ATTRIBUTE));
if( attributeChanges.containsKey(IPackageFileSet.IN_WORKSPACE_ATTRIBUTE))
fs.setInWorkspace(getBeforeBoolean(attributeChanges, IPackageFileSet.IN_WORKSPACE_ATTRIBUTE));
undoPropertyChanges(fs, propertyChanges);
return fs;
}
protected static XbFolder createFolder(PackageFolderImpl postChange,HashMap attributeChanges, HashMap propertyChanges ) {
XbFolder folder = new XbFolder((XbFolder)postChange.nodeDelegate);
if( attributeChanges.containsKey(IPackageFolder.NAME_ATTRIBUTE))
folder.setName(getBeforeString(attributeChanges, IPackageFolder.NAME_ATTRIBUTE));
undoPropertyChanges(folder, propertyChanges);
return folder;
}
protected static XbPackage createPackage(PackageImpl postChange,HashMap attributeChanges, HashMap propertyChanges ) {
XbPackage pack = new XbPackage((XbPackage)postChange.nodeDelegate);
if( attributeChanges.containsKey(IPackage.NAME_ATTRIBUTE))
pack.setName(getBeforeString(attributeChanges, IPackage.NAME_ATTRIBUTE));
if( attributeChanges.containsKey(IPackage.PACKAGE_TYPE_ATTRIBUTE))
pack.setPackageType(getBeforeString(attributeChanges, IPackage.PACKAGE_TYPE_ATTRIBUTE));
if( attributeChanges.containsKey(IPackage.DESTINATION_ATTRIBUTE))
pack.setToDir(getBeforeString(attributeChanges, IPackage.DESTINATION_ATTRIBUTE));
if( attributeChanges.containsKey(IPackage.IN_WORKSPACE_ATTRIBUTE))
pack.setInWorkspace(getBeforeBoolean(attributeChanges, IPackage.IN_WORKSPACE_ATTRIBUTE));
if( attributeChanges.containsKey(IPackage.EXPLODED_ATTRIBUTE))
pack.setExploded(getBeforeBoolean(attributeChanges, IPackage.EXPLODED_ATTRIBUTE));
undoPropertyChanges(pack, propertyChanges);
return pack;
}
protected static boolean getBeforeBoolean(HashMap map, String key) {
NodeDelta delta = (NodeDelta)map.get(key);
if( delta != null ) {
return ((Boolean)delta.getBefore()).booleanValue();
}
return true;
}
protected static String getBeforeString(HashMap map, String key) {
NodeDelta delta = (NodeDelta)map.get(key);
if( delta != null ) {
return (String)delta.getBefore();
}
return null;
}
// set the properties here to what they were before the delta
protected static void undoPropertyChanges(XbPackageNodeWithProperties node, HashMap changes) {
String key;
NodeDelta val;
for( Iterator i = changes.keySet().iterator(); i.hasNext(); ) {
key = (String) i.next();
val = (NodeDelta)changes.get(key);
if( val.getBefore() == null ) {
node.getProperties().getProperties().remove(key);
} else {
node.getProperties().getProperties().setProperty(key, (String)val.getBefore());
}
}
}
public static class DeltaFileset extends PackageFileSetImpl {
// everything goes through the delegate or the parent. Simple
private PackagesModelDeltaImpl parentDelta;
public DeltaFileset(XbFileSet fileset, PackagesModelDeltaImpl parentDelta){
super(fileset);
this.parentDelta = parentDelta;
}
public IPackageNode getParent() {
return parentDelta == null ? null : parentDelta.getPreNode();
}
}
public static class DeltaFolder extends PackageFolderImpl {
private PackagesModelDeltaImpl parentDelta;
public DeltaFolder(XbFolder folder, PackagesModelDeltaImpl parentDelta){
super(folder);
this.parentDelta = parentDelta;
}
public IPackageNode getParent() {
return parentDelta == null ? null : parentDelta.getPreNode();
}
}
public static class DeltaPackage extends PackageImpl {
private PackagesModelDeltaImpl parentDelta;
public DeltaPackage(XbPackage pack, PackagesModelDeltaImpl parentDelta){
super(pack);
this.parentDelta = parentDelta;
}
public IPackageNode getParent() {
return parentDelta == null ? null : parentDelta.getPreNode();
}
}
}
1.28 +188 -577 jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackagesModel.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: PackagesModel.java
===================================================================
RCS file: PackagesModel.java
diff -N PackagesModel.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ PackagesModel.java 16 Apr 2007 17:34:42 -0000 1.28
@@ -0,0 +1,281 @@
+package org.jboss.ide.eclipse.packages.core.model.internal;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.jboss.ide.eclipse.packages.core.Trace;
+import org.jboss.ide.eclipse.packages.core.build.PackagesNature;
+import org.jboss.ide.eclipse.packages.core.model.IPackage;
+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.IPackagesModelDelta;
+import org.jboss.ide.eclipse.packages.core.model.events.EventManager;
+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;
+
+public class PackagesModel {
+
+ public static final String PROJECT_PACKAGES_FILE = ".packages";
+
+ /**
+ * Singleton instance
+ */
+ protected static PackagesModel instance;
+ public static PackagesModel instance() {
+ if( instance == null )
+ instance = new PackagesModel();
+ return instance;
+ }
+
+ private HashMap xbPackages; // maps an IProject to XbPackages
+ private HashMap packagesRoot; // maps an IProject to PackageModelNode, aka root
+ public PackagesModel() {
+ xbPackages = new HashMap();
+ packagesRoot = new HashMap();
+ }
+
+ public XbPackages getXbPackages(IProject project) {
+ return (XbPackages)(xbPackages.get(project));
+ }
+
+ /**
+ * If the project hasn't been registered, register it
+ * @param project
+ * @param monitor
+ * @return
+ */
+ public XbPackages getXbPackages(IProject project, IProgressMonitor monitor) {
+ if( !xbPackages.containsKey(project))
+ registerProject(project, monitor);
+ return (XbPackages)(xbPackages.get(project));
+ }
+
+ public boolean accept(IPackageNodeVisitor visitor) {
+ IPackageNode children[] = getAllPackages();
+ boolean keepGoing = true;
+
+ if (keepGoing) {
+ for (int i = 0; i < children.length; i++) {
+ if (keepGoing) {
+ keepGoing = children[i].accept(visitor);
+ }
+ }
+ }
+
+ return keepGoing;
+ }
+
+ /**
+ * Gets every single registered model
+ * @return
+ */
+ protected PackageModelNode[] getAllPackages() {
+ PackageModelNode[] ret = new PackageModelNode[packagesRoot.keySet().size()];
+ Iterator i = packagesRoot.keySet().iterator();
+ int x = 0;
+ while(i.hasNext()) {
+ ret[x++] = (PackageModelNode)packagesRoot.get(i.next());
+ }
+ return ret;
+ }
+
+ public PackageModelNode getRoot(IProject project) {
+ return getRoot(project, false, new NullProgressMonitor());
+ }
+
+ public PackageModelNode getRoot(IProject project, boolean force, IProgressMonitor monitor) {
+ if( packagesRoot.get(project) == null && force ) {
+ registerProject(project, monitor);
+ }
+ return (PackageModelNode)(packagesRoot.get(project));
+ }
+
+ public IPackage[] getProjectPackages(IProject project) {
+ PackageModelNode root = getRoot(project);
+ if( root != null ) {
+ List list = Arrays.asList( getRoot(project).getAllChildren());
+ return (IPackage[]) list.toArray(new IPackage[list.size()]);
+ } else {
+ return null;
+ }
+ }
+
+ // to make sure the node root is actually in the model
+ public boolean containsRoot(PackageModelNode node) {
+ return packagesRoot.containsValue(node);
+ }
+
+ public void registerProject(IProject project, IProgressMonitor monitor) {
+ // if the file exists, read it in
+
+ monitor.beginTask("Loading configuration...", XMLBinding.NUM_UNMARSHAL_MONITOR_STEPS + 2);
+
+ try {
+ if (!project.hasNature(PackagesNature.NATURE_ID)) {
+ addProjectNature(project, PackagesNature.NATURE_ID);
+ }
+ } catch (CoreException e) {
+ Trace.trace(getClass(), e);
+ }
+
+ PackageModelNode root;
+ IFile packagesFile = project.getFile(PROJECT_PACKAGES_FILE);
+ if (packagesFile.exists())
+ {
+ try {
+ XbPackages packages = XMLBinding.unmarshal(packagesFile.getContents(), monitor);
+ monitor.worked(1);
+
+ if (packages == null) {
+ // Empty / non-working XML file loaded
+ Trace.trace(getClass(), "WARNING: .packages file for project " + project.getName() + " is empty or contains the wrong content");
+ return;
+ }
+ root = new PackageModelNode(project, packages);
+ xbPackages.put(project, packages);
+ packagesRoot.put(project, root);
+ createPackageNodeImpl(project, packages, null);
+ root.clearDeltas();
+ monitor.worked(1);
+ } catch (CoreException e) {
+ Trace.trace(getClass(), e);
+ }
+ } else {
+ // file not found, just create some default xbpackages and insert them
+ XbPackages packages = new XbPackages();
+ xbPackages.put(project, packages);
+ packagesRoot.put(project, new PackageModelNode(project, packages));
+ }
+ }
+
+ protected PackageNodeImpl createPackageNodeImpl (IProject project, XbPackageNode node, IPackageNode parent) {
+
+ if( node instanceof XbPackages ) {
+ PackageModelNode impl = getRoot(project);
+ for (Iterator iter = node.getAllChildren().iterator(); iter.hasNext(); ) {
+ XbPackageNode child = (XbPackageNode) iter.next();
+ PackageNodeImpl childImpl = createPackageNodeImpl(project, child, impl);
+ if (impl != null && childImpl != null) {
+ impl.addChild(childImpl, false);
+ }
+ }
+ return null;
+ }
+
+ PackageNodeImpl nodeImpl = null;
+ if (node instanceof XbPackage) {
+ nodeImpl = new PackageImpl((XbPackage)node);
+ } else if (node instanceof XbFolder) {
+ nodeImpl = new PackageFolderImpl((XbFolder)node);
+ } else if (node instanceof XbFileSet) {
+ nodeImpl = new PackageFileSetImpl((XbFileSet)node);
+ }
+
+ for (Iterator iter = node.getAllChildren().iterator(); iter.hasNext(); ) {
+ XbPackageNode child = (XbPackageNode) iter.next();
+ PackageNodeImpl childImpl = createPackageNodeImpl(project, child, nodeImpl);
+ if (nodeImpl != null && childImpl != null) {
+ nodeImpl.addChild(childImpl, false);
+ }
+ }
+
+ return nodeImpl;
+ }
+
+ public static boolean addProjectNature(IProject project, String natureId) {
+ boolean added = false;
+ try {
+ if (project != null && natureId != null) {
+ IProjectDescription desc = project.getDescription();
+
+ if (!project.hasNature(natureId)) {
+ String natureIds[] = desc.getNatureIds();
+ String newNatureIds[] = new String[natureIds.length + 1];
+
+ System.arraycopy(natureIds, 0, newNatureIds, 1, natureIds.length);
+ newNatureIds[0] = natureId;
+ desc.setNatureIds(newNatureIds);
+
+ project.getProject().setDescription(desc, new NullProgressMonitor());
+ added = true;
+ }
+ }
+ } catch (CoreException e) {
+ e.printStackTrace();
+ }
+ return added;
+ }
+
+ public void saveModel (IProject project, IProgressMonitor monitor) {
+ // get a list of dirty nodes
+
+ try {
+ if (monitor == null)
+ monitor = new NullProgressMonitor();
+
+ ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
+ OutputStreamWriter writer = new OutputStreamWriter(bytesOut);
+ XbPackages packs = getXbPackages(project);
+ XMLBinding.marshal(packs, writer, monitor);
+ writer.close();
+
+ ByteArrayInputStream bytesIn = new ByteArrayInputStream(bytesOut.toByteArray());
+ IFile packagesFile = project.getFile(PackagesModel.PROJECT_PACKAGES_FILE);
+ if (!packagesFile.exists())
+ packagesFile.create(bytesIn, true, monitor);
+ else
+ packagesFile.setContents(bytesIn, true, true, monitor);
+
+ bytesIn.close();
+ bytesOut.close();
+
+ if (!project.hasNature(PackagesNature.NATURE_ID)) {
+ addProjectNature(project, PackagesNature.NATURE_ID);
+ }
+
+ // get deltas
+ try {
+ PackageModelNode root = getRoot(project);
+ IPackagesModelDelta delta = root.getDelta();
+
+ // clear deltas
+ root.clearDeltas();
+
+ // fire delta events
+ EventManager.fireDelta(delta);
+ } catch( Exception e ) {
+ e.printStackTrace();
+ }
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } catch (CoreException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ public void attach(IPackageNode parent, IPackageNode child, IProgressMonitor monitor) {
+ parent.addChild(child);
+ if( parent.connectedToModel() && parent.getProject() != null) {
+ // save
+ saveModel(parent.getProject(), monitor);
+ }
+ }
+}
1.14 +188 -132 jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageNodeImpl.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: PackageNodeImpl.java
===================================================================
RCS file: PackageNodeImpl.java
diff -N PackageNodeImpl.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ PackageNodeImpl.java 16 Apr 2007 17:34:42 -0000 1.14
@@ -0,0 +1,337 @@
+/*
+ * 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.HashMap;
+import java.util.Iterator;
+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.IPackagesModelDelta;
+import org.jboss.ide.eclipse.packages.core.model.internal.PackagesModelDeltaImpl.NodeDelta;
+import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackageNode;
+import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackageNodeWithProperties;
+import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackages;
+
+public abstract class PackageNodeImpl implements IPackageNode {
+
+ protected XbPackageNodeWithProperties nodeDelegate;
+ protected IPackageNode parent;
+ protected ArrayList children;
+
+ // cached data
+ protected HashMap attributeChanges;
+ protected HashMap propertyChanges;
+ protected HashMap childChanges;
+
+
+ public PackageNodeImpl (XbPackageNodeWithProperties delegate) {
+ nodeDelegate = delegate;
+ children = new ArrayList();
+
+ // for deltas
+ attributeChanges = new HashMap();
+ propertyChanges = new HashMap();
+ childChanges = new HashMap();
+ }
+
+ public XbPackageNode getNodeDelegate() {
+ return nodeDelegate;
+ }
+
+ public IPackageNode getRoot() {
+ return parent == null ? this : parent.getRoot();
+ }
+
+
+ public IPackageNode[] getAllChildren () {
+ return (IPackageNode[]) children.toArray(new IPackageNode[children.size()]);
+ }
+
+ public IPackageNode[] getChildren(int type) {
+ ArrayList typedChildren = new ArrayList();
+ for (Iterator iter = children.iterator(); iter.hasNext(); ) {
+ IPackageNode child = (IPackageNode) iter.next();
+ if (child.getNodeType() == type) {
+ typedChildren.add(child);
+ }
+ }
+
+ return (IPackageNode[]) typedChildren.toArray(new IPackageNode[typedChildren.size()]);
+ }
+
+ public boolean hasChildren () {
+ return nodeDelegate.hasChildren();
+ }
+
+ public boolean hasChild (IPackageNode child) {
+ PackageNodeImpl childImpl = (PackageNodeImpl)child;
+ return nodeDelegate.getAllChildren().contains(childImpl.nodeDelegate);
+ }
+
+ public IPackageNode getParent() {
+ return parent;
+ }
+
+ public void setParent (IPackageNode parent) {
+ if( getParent() != null && parent != getParent()) {
+ getParent().removeChild(this);
+ }
+
+ if (parent != null && !(parent instanceof PackageModelNode)) {
+ this.parent = parent;
+ nodeDelegate.setParent(((PackageNodeImpl)parent).getNodeDelegate());
+ } else if (getNodeType() == TYPE_PACKAGE) {
+ this.parent = parent;
+ XbPackages packages = PackagesModel.instance().getXbPackages(getProject());
+ nodeDelegate.setParent(packages);
+ }
+ }
+
+ public IProject getProject() {
+ IPackageNode root = getRoot();
+ if( root.getNodeType() != IPackageNode.TYPE_MODEL)
+ return null;
+ return root.getProject();
+ }
+
+ public String getProperty(String property) {
+ return getProperties().getProperty(property);
+ }
+
+ public void setProperty(String property, String value) {
+ if( property == null ) return;
+ propertyChanged(property, getProperty(property), value);
+ if( value == null ) {
+ getProperties().remove(property);
+ } else {
+ getProperties().setProperty(property, value);
+ }
+ }
+
+ 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) {
+ addChild(node, true);
+ }
+
+ public void addChild(IPackageNode child, boolean addInDelegate) {
+ Assert.isNotNull(child);
+ PackageNodeImpl childImpl = (PackageNodeImpl) child;
+ children.add(childImpl);
+ childImpl.setParent(this);
+ if( addInDelegate )
+ nodeDelegate.addChild(childImpl.nodeDelegate);
+ childChanges(child, IPackagesModelDelta.CHILD_ADDED);
+ }
+
+ public void removeChild(IPackageNode node) {
+ Assert.isNotNull(node);
+ PackageNodeImpl impl = (PackageNodeImpl) node;
+ boolean removed = false;
+ if (nodeDelegate.getAllChildren().contains(impl.nodeDelegate)) {
+ nodeDelegate.removeChild(impl.nodeDelegate);
+ removed = true;
+ }
+
+ if (children.contains(node)) {
+ children.remove(node);
+ removed = true;
+ }
+ if( removed )
+ childChanges(node, IPackagesModelDelta.CHILD_REMOVED);
+ }
+
+ public Object getAdapter(Class adapter) {
+ if (adapter.equals(IProject.class)) {
+ return getProject();
+ } else if (adapter.equals(IPackageNode.class)) {
+ return this;
+ }
+ else return null;
+ }
+
+ /**
+ * Is this method necessary? Some of the interfaces have a similar method
+ * This is only used in destination composite in the UI so far.
+ * TODO: Determine which is necessary, this method or getRootArchiveRelativePath
+ * @return
+ */
+// public IPath getPackageRelativePath() {
+// String path = "";
+// if (getNodeType() == IPackageNode.TYPE_PACKAGE ) {
+// if (getParent() == null) return null;
+// path = ((IPackage)this).getName();
+// } else if (getNodeType() == IPackageNode.TYPE_PACKAGE_FOLDER) {
+// path = ((IPackageFolder)this).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 instanceof PackageModelNode ) {
+// parent = save;
+// break;
+// }
+// }
+// if (path.charAt(path.length()-1) == '/') {
+// path = path.substring(0, path.length() - 1);
+// }
+// return new Path(path);
+// }
+
+ public boolean connectedToModel() {
+ IPackageNode root = getRoot();
+ return root instanceof PackageModelNode && PackagesModel.instance().containsRoot((PackageModelNode)root);
+ }
+
+
+ /*
+ * The following are for deltas. It keeps track of recent changes
+ * and makes sure all changes are accoutned for properly between saves
+ */
+ protected void attributeChanged(String key, Object beforeValue, Object afterValue) {
+ int kind = IPackagesModelDelta.ATTRIBUTE_CHANGED;
+ HashMap map = attributeChanges;
+
+ // short circuit if no change has REALLY occurred
+ if( beforeValue != null && beforeValue.equals(afterValue)) return;
+
+ if( map.containsKey(key)) {
+ Object original = ((NodeDelta)map.get(key)).getBefore();
+ if( original == null && afterValue == null )
+ map.remove(key);
+ else if( original == null )
+ map.put(key, new NodeDelta(original, afterValue, kind));
+ else if( original.equals(afterValue))
+ // value was changed from x to y, then back to x. Therefore, no change
+ map.remove(key);
+ else
+ // value was changed from x to y to z.
+ // Before should remain x, after should become z
+ map.put(key, new NodeDelta(original, afterValue, kind));
+ } else {
+ // added
+ map.put(key, new NodeDelta(beforeValue, afterValue, kind));
+ }
+ }
+
+ protected void propertyChanged(String key, Object beforeValue, Object afterValue) {
+ HashMap changeMap = propertyChanges;
+ // short circuit if no change has REALLY occurred
+ if( beforeValue != null && beforeValue.equals(afterValue)) return;
+
+
+ if( changeMap.containsKey(key)) {
+ // element has already been added, removed, or changed since last save
+ Object original = ((NodeDelta)changeMap.get(key)).getBefore();
+ if( original == null && afterValue == null )
+ changeMap.remove(key);
+ else if( original == null )
+ changeMap.put(key, new NodeDelta(original, afterValue, IPackagesModelDelta.PROPERTY_ADDED));
+ else if( original.equals(afterValue))
+ // value was changed from x to y, then back to x. Therefore, no change
+ changeMap.remove(key);
+ else if( afterValue == null ) {
+ // changed from x to y to null, so removed
+ changeMap.put(key, new NodeDelta(original, afterValue, IPackagesModelDelta.PROPERTY_REMOVED));
+ } else {
+ // changed from x to y to z, so changed
+ changeMap.put(key, new NodeDelta(original, afterValue, IPackagesModelDelta.PROPERTY_CHANGED));
+ }
+ } else {
+ int kind;
+ if( beforeValue == null ) kind = IPackagesModelDelta.PROPERTY_ADDED;
+ else if( afterValue == null ) kind = IPackagesModelDelta.PROPERTY_REMOVED;
+ else kind = IPackagesModelDelta.PROPERTY_CHANGED;
+ changeMap.put(key, new NodeDelta(beforeValue, afterValue, kind));
+ }
+ }
+
+ // children are either added or removed here.
+ // changed children are discovered through the delta
+ protected void childChanges(IPackageNode node, int changeType) {
+ if( childChanges.containsKey(node)) {
+ int lastChange = ((Integer)childChanges.get(node)).intValue();
+ if( lastChange == IPackagesModelDelta.CHILD_ADDED && changeType == IPackagesModelDelta.CHILD_REMOVED) {
+ childChanges.remove(node);
+ } else if( lastChange == IPackagesModelDelta.CHILD_REMOVED && changeType == IPackagesModelDelta.CHILD_ADDED) {
+ childChanges.remove(node);
+ }
+ } else {
+ childChanges.put(node, new Integer(changeType));
+ }
+ }
+
+ public IPackagesModelDelta getDelta() {
+ return new PackagesModelDeltaImpl(null, this, (HashMap)attributeChanges.clone(),
+ (HashMap)propertyChanges.clone(), (HashMap)childChanges.clone());
+ }
+
+ protected void clearDeltas() {
+ attributeChanges.clear();
+ propertyChanges.clear();
+ childChanges.clear();
+
+ // clear children
+ IPackageNode[] children = getAllChildren();
+ for( int i = 0; i < children.length; i++ )
+ ((PackageNodeImpl)children[i]).clearDeltas();
+ }
+}
1.1 date: 2007/04/16 17:34:42; author: rawb; state: Exp;jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageModelNode.java
Index: PackageModelNode.java
===================================================================
package org.jboss.ide.eclipse.packages.core.model.internal;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IPath;
import org.jboss.ide.eclipse.packages.core.model.IPackage;
import org.jboss.ide.eclipse.packages.core.model.IPackageNode;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackageNodeWithProperties;
import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackages;
public class PackageModelNode extends PackageNodeImpl {
private IProject project;
public PackageModelNode(IProject project, XbPackageNodeWithProperties node) {
super(node);
this.project = project;
}
public IProject getProject() {
return project;
}
public XbPackages getXbPackages() {
return (XbPackages)nodeDelegate;
}
// Can only add packages types here
public void addChild(IPackageNode child) {
if( child instanceof IPackage ) {
super.addChild(child);
}
}
public int getNodeType() {
return IPackageNode.TYPE_MODEL;
}
public IPackageNode getRoot() {
return this;
}
public boolean connectedToModel() {
return PackagesModel.instance().containsRoot(this);
}
public IPackageNode getParent() {
return null;
}
public void setParent(IPackageNode parent) {
}
public IPath getRootArchiveRelativePath() {
return null;
}
public IPath[] getPackagePaths() {
return null;
}
}
1.22 +42 -136 jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageImpl.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: PackageImpl.java
===================================================================
RCS file: PackageImpl.java
diff -N PackageImpl.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ PackageImpl.java 16 Apr 2007 17:34:42 -0000 1.22
@@ -0,0 +1,168 @@
+/*
+ * 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.ResourcesPlugin;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.jboss.ide.eclipse.packages.core.ExtensionManager;
+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.internal.xb.XbPackage;
+import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbPackages;
+import org.jboss.ide.eclipse.packages.core.model.types.IPackageType;
+
+/**
+ * A Package.
+ *
+ * @author Rob stryker
+ */
+public class PackageImpl extends PackageNodeImpl implements IPackage {
+
+ private XbPackage packageDelegate;
+
+ public PackageImpl() {
+ this(new XbPackage());
+ }
+ public PackageImpl(XbPackage delegate) {
+ super(delegate);
+ this.packageDelegate = delegate;
+ }
+
+ public int getNodeType() {
+ return TYPE_PACKAGE;
+ }
+
+ public boolean isDestinationInWorkspace() {
+ return packageDelegate.isInWorkspace();
+ }
+
+ public IPath getDestinationPath () {
+ if (packageDelegate.getToDir() == null || packageDelegate.getToDir().equals("."))
+ return getProject() == null ? null : getProject().getLocation();
+
+ if (isDestinationInWorkspace()) {
+ return ResourcesPlugin.getWorkspace().getRoot().getLocation().append(new Path(packageDelegate.getToDir()));
+ } else
+ return new Path(packageDelegate.getToDir());
+ }
+
+ public IPath getPackageFilePath() {
+ return getDestinationPath().append(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 String getName() {
+ return packageDelegate.getName();
+ }
+
+ public IPackageType getPackageType() {
+ return ExtensionManager.getPackageType(packageDelegate.getPackageType());
+ }
+
+ public boolean isExploded() {
+ return packageDelegate.isExploded();
+ }
+
+ public boolean isTopLevel() {
+ return (packageDelegate.getParent() instanceof XbPackages);
+ }
+
+ public void addFileSet(IPackageFileSet fileset) {
+ addChild(fileset);
+ }
+
+ public void addFolder(IPackageFolder folder) {
+ addChild(folder);
+ }
+
+ public void addPackage(IPackage pkg) {
+ addChild(pkg);
+ }
+
+ public void setDestinationPath(IPath path, boolean inWorkspace) {
+ IPath destPath = getDestinationPath();
+ attributeChanged(IN_WORKSPACE_ATTRIBUTE, new Boolean(isDestinationInWorkspace()), new Boolean(inWorkspace));
+ attributeChanged(DESTINATION_ATTRIBUTE, destPath == null ? null : destPath.toString(), path == null ? null : path.toString());
+ packageDelegate.setInWorkspace(inWorkspace);
+ packageDelegate.setToDir(path.toString());
+ }
+
+ public void setExploded(boolean exploded) {
+ attributeChanged(EXPLODED_ATTRIBUTE, new Boolean(isExploded()), new Boolean(exploded));
+ packageDelegate.setExploded(exploded);
+ }
+
+ public void setName(String name) {
+ attributeChanged(NAME_ATTRIBUTE, getName(), name);
+ packageDelegate.setName(name);
+ }
+
+ public void setPackageType(IPackageType type) {
+ attributeChanged(PACKAGE_TYPE_ATTRIBUTE, getPackageTypeId(), type == null ? null : type.getId());
+ packageDelegate.setPackageType(type.getId());
+ }
+
+ protected XbPackage getPackageDelegate () {
+ return packageDelegate;
+ }
+
+ public void setPackageType(String type) {
+ attributeChanged(PACKAGE_TYPE_ATTRIBUTE, getPackageTypeId(), type);
+ packageDelegate.setPackageType(type);
+ }
+
+ public String toString() {
+ return getName();
+ }
+ public String getPackageTypeId() {
+ return packageDelegate.getPackageType();
+ }
+ public IPath getRootArchiveRelativePath() {
+ if( getParent() == null || getParent().getRootArchiveRelativePath() == null )
+ return new Path(getName());
+ return getParent().getRootArchiveRelativePath().append(getName());
+ }
+
+}
1.1 date: 2007/04/16 17:34:42; author: rawb; state: Exp;jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackagesModelDeltaImpl.java
Index: PackagesModelDeltaImpl.java
===================================================================
package org.jboss.ide.eclipse.packages.core.model.internal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import org.jboss.ide.eclipse.packages.core.model.IPackageNode;
import org.jboss.ide.eclipse.packages.core.model.IPackagesModelDelta;
public class PackagesModelDeltaImpl implements IPackagesModelDelta {
private PackagesModelDeltaImpl parentDelta;
private PackageNodeImpl postNode, preNode;
private HashMap attributes, properties, children;
private int kind;
private IPackagesModelDelta[] childrenDeltas;
/**
* Primary constructor
* @param parentDelta
* @param impl
* @param attributeChanges
* @param propertyChanges
* @param childChanges
*/
public PackagesModelDeltaImpl(PackagesModelDeltaImpl parentDelta, PackageNodeImpl impl,
HashMap attributeChanges, HashMap propertyChanges, HashMap childChanges) {
this.parentDelta = parentDelta;
postNode = impl;
kind = 0;
properties = propertyChanges;
attributes = attributeChanges;
children = childChanges;
// These three lines adjust my "kind" to be accurate
ensureAccurateKind();
// create *my* pre-node
// this creates an accurate "old" node but without ANY children at all.
// The children are expected to be added in the getAffectedChildren
preNode = PackagesModelDeltaPreFactory.createNode(parentDelta, postNode, attributeChanges, propertyChanges);
getAffectedChildren();
}
/**
* Constructor that forces a child to be added or removed, as judged by the parent
* @param parentDelta
* @param impl
* @param forcedKind
* @param attributeChanges
* @param propertyChanges
* @param childChanges
*/
public PackagesModelDeltaImpl(PackagesModelDeltaImpl parentDelta, PackageNodeImpl impl,
int forcedKind, HashMap attributeChanges,
HashMap propertyChanges, HashMap childChanges) {
this(parentDelta, impl, attributeChanges, propertyChanges, childChanges);
kind = kind | forcedKind; // pre-gaming
}
/**
* Get the parent delta
* @return
*/
protected PackagesModelDeltaImpl getParentDelta() {
return parentDelta;
}
protected void ensureAccurateKind() {
// Properties First
Object key;
NodeDelta val;
for( Iterator i = properties.keySet().iterator(); i.hasNext(); ) {
key = i.next();
val = (NodeDelta)properties.get(key);
kind = kind | val.getKind();
}
// Attributes Second
if( attributes.keySet().size() > 0 )
kind = kind | ATTRIBUTE_CHANGED;
/*
* Children third.
*
* The changed children are saved in a hashmap
* Node -> Integer (where int is one of
* IPackagesModelDelta.CHILD_ADDED or
* IPackagesModelDelta.CHILD_REMOVED
*/
Integer val2;
for( Iterator i = children.keySet().iterator(); i.hasNext(); ) {
key = i.next();
val2 = (Integer)children.get(key);
if( val2 != null )
kind = kind | val2.intValue();
}
}
// Forced during constructor, will set the flag for CHILD_CHANGED if a child has changed at all.
public IPackagesModelDelta[] getAffectedChildren() {
ArrayList priorChildren = new ArrayList();
if( childrenDeltas == null ) {
// first add the deltas for things that are currently our children
// this includes items that haven't been changed, and items that were added
IPackageNode[] children = postNode.getAllChildren();
IPackagesModelDelta delta;
ArrayList deltas = new ArrayList();
for( int i = 0; i < children.length; i++ ) {
// create our child delta before evaluating whether or not to add it
delta = getDelta(children[i]);
if( delta.getKind() != IPackagesModelDelta.NO_CHANGE ) {
deltas.add(delta);
kind = kind | DESCENDENT_CHANGED;
}
// add ALL current nodes, then later remove the added ones
priorChildren.add(delta.getPreNode());
}
// now handle the removed ones
PackageNodeImpl node;
for(Iterator i = this.children.keySet().iterator(); i.hasNext(); ) {
node = (PackageNodeImpl)i.next();
int v = ((Integer)this.children.get(node)).intValue();
delta = getDelta(node);
if( v == IPackagesModelDelta.CHILD_REMOVED) {
deltas.add(delta);
priorChildren.add(delta.getPreNode());
} else if( v == IPackagesModelDelta.CHILD_ADDED) {
priorChildren.remove(delta.getPreNode());
}
}
if( preNode != null ) {
// now we've got our list of current children... set them.
for( Iterator i = priorChildren.iterator(); i.hasNext(); ) {
preNode.addChild((IPackageNode)i.next());
}
// now clear pre-node's deltas so it looks shiny
preNode.clearDeltas();
}
childrenDeltas = (IPackagesModelDelta[]) deltas.toArray(new IPackagesModelDelta[deltas.size()]);
}
return childrenDeltas;
}
/*
* Because a node can be ADDED with respect to one node, and
* REMOVED with respect to another, that portion of the delta
* kind must be set here, from the parent, rather than in the
* child.
*/
private IPackagesModelDelta getDelta(IPackageNode child) {
if( child instanceof PackageNodeImpl ) {
int addedOrRemoved = 0;
if( children.containsKey(child)) {
addedOrRemoved = ((Integer)children.get(child)).intValue() >> 8;
}
PackageNodeImpl impl = (PackageNodeImpl)child;
// Using a different delta constructor here to force
// whether this child is added or removed.
return new PackagesModelDeltaImpl(this, impl, addedOrRemoved,
(HashMap)impl.attributeChanges.clone(),
(HashMap)impl.propertyChanges.clone(),
(HashMap)impl.childChanges.clone());
}
return child.getDelta();
}
public int getKind() {
return kind;
}
public IPackageNode getPostNode() {
return postNode;
}
public IPackageNode getPreNode() {
return preNode;
}
public String[] getAttributesWithDeltas() {
Collection atts = attributes.keySet();
return (String[]) atts.toArray(new String[atts.size()]);
}
public INodeDelta getAttributeDelta(String key) {
return (INodeDelta)attributes.get(key);
}
public String[] getPropertiesWithDeltas() {
Collection atts = properties.keySet();
return (String[]) atts.toArray(new String[atts.size()]);
}
public INodeDelta getPropertyDelta(String key) {
return (INodeDelta)properties.get(key);
}
public IPackagesModelDelta[] getAddedChildrenDeltas() {
return getChangedChildren(IPackagesModelDelta.ADDED);
}
public IPackagesModelDelta[] getRemovedChildrenDeltas() {
return getChangedChildren(IPackagesModelDelta.REMOVED);
}
private IPackagesModelDelta[] getChangedChildren(int type) {
ArrayList list = new ArrayList();
for( int i = 0; i < childrenDeltas.length; i++ ) {
if( (childrenDeltas[i].getKind() & type) != 0 ) {
list.add(childrenDeltas[i]);
}
}
return (IPackagesModelDelta[]) list.toArray(new IPackagesModelDelta[list.size()]);
}
/**
* A quick and dirty class to keep track of changing
* values between saves in a model.
* Used for property changes and attribute changes
* @author rstryker
*
*/
protected static class NodeDelta implements INodeDelta {
private int kind;
private Object before, after;
public NodeDelta(Object before, Object after, int kind) {
this.before = before;
this.after = after;
this.kind = kind;
}
public Object getBefore() { return before; }
public Object getAfter() { return after; }
public int getKind() {
return kind;
}
}
}
1.7 +10 -5 jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageFolderImpl.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: PackageFolderImpl.java
===================================================================
RCS file: PackageFolderImpl.java
diff -N PackageFolderImpl.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ PackageFolderImpl.java 16 Apr 2007 17:34:42 -0000 1.7
@@ -0,0 +1,106 @@
+/*
+ * 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.runtime.IPath;
+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.internal.xb.XbFolder;
+
+/**
+ * A PackageFolderImpl.
+ *
+ * @author <a href="marshall at jboss.org">Marshall Culpepper</a>
+ * @version $Revision: 1.7 $
+ */
+public class PackageFolderImpl extends PackageNodeImpl implements
+ IPackageFolder {
+
+ private XbFolder folderDelegate;
+
+ public PackageFolderImpl() {
+ this(new XbFolder());
+ }
+ public PackageFolderImpl(XbFolder delegate) {
+ super(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) {
+ attributeChanged(NAME_ATTRIBUTE, getName(), name);
+ folderDelegate.setName(name);
+ }
+
+ protected XbFolder getFolderDelegate ()
+ {
+ return folderDelegate;
+ }
+
+ public String toString() {
+ return "folder[" + getName() + "]";
+ }
+ public IPath getRootArchiveRelativePath() {
+ return getParent().getRootArchiveRelativePath().append(getName());
+ }
+}
1.13 +70 -205 jbosside/core/plugins/org.jboss.ide.eclipse.packages.core/src/main/org/jboss/ide/eclipse/packages/core/model/internal/PackageFileSetImpl.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: PackageFileSetImpl.java
===================================================================
RCS file: PackageFileSetImpl.java
diff -N PackageFileSetImpl.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ PackageFileSetImpl.java 16 Apr 2007 17:34:42 -0000 1.13
@@ -0,0 +1,169 @@
+/*
+ * 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 org.eclipse.core.resources.IFile;
+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.DirectoryScannerFactory;
+import org.jboss.ide.eclipse.packages.core.model.IPackageFileSet;
+import org.jboss.ide.eclipse.packages.core.model.DirectoryScannerFactory.DirectoryScannerExtension;
+import org.jboss.ide.eclipse.packages.core.model.internal.xb.XbFileSet;
+
+/**
+ * A PackageFileSetImpl.
+ */
+public class PackageFileSetImpl extends PackageNodeImpl implements
+ IPackageFileSet {
+
+ private XbFileSet filesetDelegate;
+ private DirectoryScannerExtension scanner;
+ private boolean rescanRequired = true;
+
+ public PackageFileSetImpl() {
+ this(new XbFileSet());
+ }
+
+ public PackageFileSetImpl (XbFileSet delegate) {
+ super(delegate);
+ this.filesetDelegate = delegate;
+ }
+
+ public IPath[] findMatchingPaths () {
+ DirectoryScannerExtension scanner = getScanner();
+ ArrayList paths = new ArrayList();
+ IPath sp = getSourcePath();
+ String matched[] = scanner.getIncludedFiles();
+ for (int i = 0; i < matched.length; i++) {
+ IPath path = sp.append(new Path(matched[i]));
+ paths.add(path);
+ }
+
+ return (IPath[])paths.toArray(new IPath[paths.size()]);
+ }
+
+ public String getExcludesPattern() {
+ return filesetDelegate.getExcludes();
+ }
+
+ public boolean isInWorkspace() {
+ return filesetDelegate.isInWorkspace();
+ }
+
+ public String getIncludesPattern() {
+ return filesetDelegate.getIncludes();
+ }
+
+ // returns a file-system relative path
+ public IPath getSourcePath() {
+ String path = filesetDelegate.getDir();
+ if (path == null || path.equals(".") || path.equals("")) {
+ return getProject() == null ? null : getProject().getLocation();
+ } else if( isInWorkspace()){
+ return ResourcesPlugin.getWorkspace().getRoot().getLocation().append(path);
+ } else {
+ return new Path(path);
+ }
+ }
+
+ public boolean matchesFile(IFile file) {
+ return matchesFile(getScanner(), file);
+ }
+
+ public boolean matchesFile(DirectoryScannerExtension scanner, IFile file) {
+ return matchesPath(file.getLocation());
+ }
+
+ public boolean matchesPath(IPath path) {
+ return matchesPath(getScanner(), path);
+ }
+
+ public boolean matchesPath(DirectoryScannerExtension scanner, IPath path) {
+ if( getSourcePath().isPrefixOf(path)) {
+ String s = path.toOSString().substring(getSourcePath().toOSString().length()+1);
+ return scanner.isIncluded(s);
+ }
+ return false;
+ }
+
+ private synchronized DirectoryScannerExtension getScanner() {
+ if( scanner == null || rescanRequired) {
+ rescanRequired = false;
+ scanner = DirectoryScannerFactory.createDirectoryScanner(
+ getSourcePath(), getIncludesPattern(), getExcludesPattern(), true);
+ }
+ return scanner;
+ }
+
+ public int getNodeType() {
+ return TYPE_PACKAGE_FILESET;
+ }
+
+ public void setExcludesPattern(String excludes) {
+ attributeChanged(EXCLUDES_ATTRIBUTE, getExcludesPattern(), excludes);
+ filesetDelegate.setExcludes(excludes);
+ }
+
+ public void setIncludesPattern(String includes) {
+ attributeChanged(INCLUDES_ATTRIBUTE, getIncludesPattern(), includes);
+ filesetDelegate.setIncludes(includes);
+ }
+
+ public void setInWorkspace(boolean isInWorkspace) {
+ attributeChanged(IN_WORKSPACE_ATTRIBUTE, new Boolean(isInWorkspace()), new Boolean(isInWorkspace));
+ filesetDelegate.setInWorkspace(isInWorkspace);
+ }
+
+ public void setSourcePath (IPath path) {
+ Assert.isNotNull(path);
+ IPath src = getSourcePath();
+ attributeChanged(SOURCE_PATH_ATTRIBUTE, src == null ? null : src.toString(), path == null ? null : path.toString());
+ filesetDelegate.setDir(path.toString());
+ }
+
+ protected XbFileSet getFileSetDelegate () {
+ return filesetDelegate;
+ }
+
+ // filesets have no path of their own
+ // and should not be the parents of any other node
+ // so the parent is their base location
+ public IPath getRootArchiveRelativePath() {
+ return getParent().getRootArchiveRelativePath();
+ }
+
+ public IPath getRootPackageRelativePath(IPath inputFile) {
+ if( matchesPath(inputFile)) {
+ String s = inputFile.toOSString().substring(getSourcePath().toOSString().length()+1);
+ return getParent().getRootArchiveRelativePath().append(s);
+ }
+ return null;
+ }
+
+ public void resetScanner() {
+ rescanRequired = true;
+ }
+}
More information about the jboss-cvs-commits
mailing list