1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
|
/*******************************************************************************
* Copyright (c) 2003, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.wst.web.internal.deployables;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
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.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualArchiveComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualContainer;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.componentcore.resources.IVirtualResource;
import org.eclipse.wst.server.core.IModule;
import org.eclipse.wst.server.core.ServerUtil;
import org.eclipse.wst.server.core.internal.ModuleFile;
import org.eclipse.wst.server.core.internal.ModuleFolder;
import org.eclipse.wst.server.core.model.IModuleFolder;
import org.eclipse.wst.server.core.model.IModuleResource;
import org.eclipse.wst.server.core.util.ProjectModule;
public abstract class ComponentDeployable extends ProjectModule {
protected IVirtualComponent component = null;
protected List members = new ArrayList();
public ComponentDeployable(IProject project) {
super(project);
this.component = ComponentCore.createComponent(project);
}
/**
* @see org.eclipse.jst.server.core.IJ2EEModule#isBinary()
*/
public boolean isBinary() {
return false;
}
private void addMembersToModuleFolder(ModuleFolder mf, IModuleResource[] mr) {
if (mf == null) return;
Set membersJoin = new HashSet();
if (mf.members() != null)
membersJoin.addAll(Arrays.asList(mf.members()));
if (mr != null && mr.length > 0)
membersJoin.addAll(Arrays.asList(mr));
mf.setMembers((IModuleResource[]) membersJoin.toArray(new IModuleResource[membersJoin.size()]));
}
/**
* Returns the child modules of this module.
*
* @return org.eclipse.wst.server.core.model.IModule[]
*/
public IModule[] getChildModules() {
return getModules();
}
public IModule[] getModules() {
List modules = new ArrayList();
if (component != null) {
IVirtualReference[] components = component.getReferences();
for (int i = 0; i < components.length; i++) {
IVirtualReference reference = components[i];
IVirtualComponent virtualComp = reference.getReferencedComponent();
if (virtualComp != null && virtualComp.getProject()!=component.getProject()) {
Object module = ServerUtil.getModule(virtualComp.getProject());
if (module != null && !modules.contains(module))
modules.add(module);
}
}
}
return (IModule[]) modules.toArray(new IModule[modules.size()]);
}
/**
* Find the module resources for a given container and path. Inserts in the java containers
* at a given path if not null.
*
* @param cont a container
* @param path the current module relative path
* @param javaPath the path where Java resources fit in the root
* @param javaCont
* @return a possibly-empty array of module resources
* @throws CoreException
*/
protected IModuleResource[] getMembers(IContainer cont, IPath path, IPath javaPath, IContainer[] javaCont) throws CoreException {
IResource[] res = cont.members();
int size2 = res.length;
List list = new ArrayList(size2);
for (int j = 0; j < size2; j++) {
if (res[j] instanceof IContainer) {
IContainer cc = (IContainer) res[j];
IPath newPath = path.append(cc.getName());
// Retrieve already existing module folder if applicable
ModuleFolder mf = (ModuleFolder) getExistingModuleResource(members,newPath);
if (mf == null) {
mf = new ModuleFolder(cc, cc.getName(), path);
list.add(mf);
}
IModuleResource[] mr = getMembers(cc, newPath, javaPath, javaCont);
if (javaPath != null && newPath.isPrefixOf(javaPath))
mr = handleJavaPath(path, javaPath, newPath, javaCont, mr, cc);
addMembersToModuleFolder(mf, mr);
} else {
IFile f = (IFile) res[j];
// Handle the default package case
if (path.equals(javaPath)) {
ModuleFolder mFolder = (ModuleFolder) getExistingModuleResource(members,javaPath);
ModuleFile mFile = new ModuleFile(f, f.getName(), javaPath, f.getModificationStamp() + f.getLocalTimeStamp());
if (mFolder != null)
addMembersToModuleFolder(mFolder,new IModuleResource[]{mFile});
else
list.add(mFile);
} else {
ModuleFile mf = new ModuleFile(f, f.getName(), path, f.getModificationStamp() + f.getLocalTimeStamp());
list.add(mf);
}
}
}
IModuleResource[] mr = new IModuleResource[list.size()];
list.toArray(mr);
return mr;
}
protected IModuleResource[] getMembers(IVirtualContainer cont, IPath path) throws CoreException {
IVirtualResource[] res = cont.members();
int size2 = res.length;
List list = new ArrayList(size2);
for (int j = 0; j < size2; j++) {
if (res[j] instanceof IVirtualContainer) {
IVirtualContainer cc = (IVirtualContainer) res[j];
// Retrieve already existing module folder if applicable
ModuleFolder mf = (ModuleFolder) getExistingModuleResource(members,new Path(cc.getName()));
if (mf == null) {
mf = new ModuleFolder((IContainer)cc.getUnderlyingResource(), cc.getName(), path);
list.add(mf);
}
IModuleResource[] mr = getMembers(cc, path.append(cc.getName()));
addMembersToModuleFolder(mf, mr);
} else {
IFile f = (IFile) res[j].getUnderlyingResource();
if (!isFileInSourceContainer(f)) {
ModuleFile mf = new ModuleFile(f, f.getName(), path, f.getModificationStamp() + f.getLocalTimeStamp());
list.add(mf);
}
}
}
IModuleResource[] mr = new IModuleResource[list.size()];
list.toArray(mr);
return mr;
}
protected boolean isFileInSourceContainer(IFile file) {
return false;
}
private IModuleResource getExistingModuleResource(List aList, IPath path) {
IModuleResource result = null;
// If the list is empty, return null
if (aList==null || aList.isEmpty())
return null;
// Otherwise recursively check to see if given resource matches current resource or if it is a child
int i=0;
do {
IModuleResource moduleResource = (IModuleResource) aList.get(i);
if (moduleResource.getModuleRelativePath().append(moduleResource.getName()).equals(path))
result = moduleResource;
// if it is a folder, check its children for the resource path
else if (moduleResource instanceof IModuleFolder) {
result = getExistingModuleResource(Arrays.asList(((IModuleFolder)moduleResource).members()),path);
}
i++;
} while (result == null && i<aList.size() );
return result;
}
protected IModuleResource[] handleJavaPath(IPath path, IPath javaPath, IPath curPath, IContainer[] javaCont, IModuleResource[] mr, IContainer cc) throws CoreException {
//subclasses may override
return new IModuleResource[]{};
}
public IModuleResource[] members() throws CoreException {
members.clear();
IVirtualComponent vc = ComponentCore.createComponent(getProject());
if (vc != null) {
IVirtualFolder vFolder = vc.getRootFolder();
IModuleResource[] mr = getMembers(vFolder, Path.EMPTY);
int size = mr.length;
for (int j = 0; j < size; j++) {
if (!members.contains(mr[j]))
members.add(mr[j]);
}
List utilMembers = getUtilMembers(vc);
if (!utilMembers.isEmpty())
members.addAll(utilMembers);
}
IModuleResource[] mr = new IModuleResource[members.size()];
members.toArray(mr);
return mr;
}
protected List getUtilMembers(IVirtualComponent vc) {
List utilMembers = new ArrayList();
IVirtualReference[] components = vc.getReferences();
for (int i = 0; i < components.length; i++) {
IVirtualReference reference = components[i];
IVirtualComponent virtualComp = reference.getReferencedComponent();
if (virtualComp != null && virtualComp.isBinary()) {
IPath archivePath = ((VirtualArchiveComponent)virtualComp).getWorkspaceRelativePath();
ModuleFile mf = null;
if (archivePath != null) { //In Workspace
IFile utilFile = ResourcesPlugin.getWorkspace().getRoot().getFile(archivePath);
mf = new ModuleFile(utilFile, utilFile.getName(), reference.getRuntimePath().makeRelative());
}
else {
File extFile = ((VirtualArchiveComponent)virtualComp).getUnderlyingDiskFile();
mf = new ModuleFile(extFile, extFile.getName(), reference.getRuntimePath().makeRelative());
}
if (mf == null)
continue;
IModuleResource moduleParent = getExistingModuleResource(members, mf.getModuleRelativePath());
if (moduleParent != null && moduleParent instanceof ModuleFolder)
addMembersToModuleFolder((ModuleFolder)moduleParent, new IModuleResource[]{mf});
else
utilMembers.add(mf);
}
}
return utilMembers;
}
/**
* Returns the root folders for the resources in this module.
*
* @return a possibly-empty array of resource folders
*/
public IContainer[] getResourceFolders() {
IVirtualComponent vc = ComponentCore.createComponent(getProject());
if (vc != null) {
IVirtualFolder vFolder = vc.getRootFolder();
if (vFolder != null)
return vFolder.getUnderlyingFolders();
}
return new IContainer[]{};
}
}
|
