Attachment #31092 for bug #119146

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 119146
Collapse All | Expand All




	}

	protected IModuleResourceDelta[] getDelta(IModuleResource[] original, IModuleResource[] current) {
		if (original == null || current == null) {
			// TODO does not make sense if either is not null
			return new IModuleResourceDelta[0];
	
		List list = new ArrayList();
		
		// look for duplicates
		List found = new ArrayList();
		int size = original.length;
		int size2 = current.length;
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < size2; j++) {
				if (!found.contains(original[i]) && !found.contains(current[j]) && original[i].equals(current[j])) {
					// found a match
					found.add(original[i]);
					if (original[i] instanceof IModuleFile) {
						// include files only if the modification stamp has changed
						IModuleFile mf1 = (IModuleFile) original[i];
						IModuleFile mf2 = (IModuleFile) current[j];
						if (mf1.getModificationStamp() != mf2.getModificationStamp()) {
							list.add(new ModuleResourceDelta(original[i], IModuleResourceDelta.CHANGED));
						}
					} else {
						// include folders only if their contents have changed
						IModuleFolder mf1 = (IModuleFolder) original[i];
						IModuleFolder mf2 = (IModuleFolder) current[j];
						IModuleResourceDelta[] mrdc = getDelta(mf1.members(), mf2.members());
						if (mrdc.length > 0) {
							ModuleResourceDelta mrd = new ModuleResourceDelta(original[i], IModuleResourceDelta.NO_CHANGE);
							mrd.setChildren(mrdc);
							list.add(mrd);
						}
					}
				}
			}
		}

		List result = new ArrayList();

		// 
		Map originalMap = new HashMap();
		for (int i = 0; i < original.length; i++) {
			originalMap.put(original[i], original[i]);
		}

		// added and changed resources
		for (int i = 0; i < current.length; i++) {
			// HashMap#remove is as fast as #get, right?
			IModuleResource old = (IModuleResource) originalMap.remove(current[i]);
			if (old == null) {
				ModuleResourceDelta delta = new ModuleResourceDelta(current[i], IModuleResourceDelta.ADDED);
				if (current[i] instanceof IModuleFolder) {
					IModuleFolder currentFolder = (IModuleFolder) current[i]; 
					delta.setChildren(getDeltaTree(currentFolder.members(), IModuleResourceDelta.ADDED));
				}
				result.add(delta);
			} else {
				if (current[i] instanceof IModuleFile) {
					// include files only if the modification stamp has changed
					IModuleFile mf1 = (IModuleFile) old;
					IModuleFile mf2 = (IModuleFile) current[i];
					if (mf1.getModificationStamp() != mf2.getModificationStamp()) {
						result.add(new ModuleResourceDelta(current[i], IModuleResourceDelta.CHANGED));
					}
				} else {
					// include folders only if their contents have changed
					IModuleFolder mf1 = (IModuleFolder) old;
					IModuleFolder mf2 = (IModuleFolder) current[i];
					IModuleResourceDelta[] mrdc = getDelta(mf1.members(), mf2.members());
					if (mrdc.length > 0) {
						ModuleResourceDelta mrd = new ModuleResourceDelta(current[i], IModuleResourceDelta.NO_CHANGE);
						mrd.setChildren(mrdc);
						result.add(mrd);
					}
				}
			}
		}

		// removed resources
		for (int i = 0; i < original.length; i++) {
			if (!originalMap.containsKey(original[i])) continue;
			ModuleResourceDelta delta = new ModuleResourceDelta(original[i], IModuleResourceDelta.REMOVED);
			if (original[i] instanceof IModuleFolder) {
				IModuleFolder removedFolder = (IModuleFolder) original[i]; 
				delta.setChildren(getDeltaTree(removedFolder.members(), IModuleResourceDelta.REMOVED));
					ModuleResourceDelta mrd = new ModuleResourceDelta(current[j], IModuleResourceDelta.ADDED);
					IModuleResourceDelta[] mrdc = getDeltaTree(mf.members(), IModuleResourceDelta.ADDED);
					mrd.setChildren(mrdc);
					list.add(mrd);
				}
			}
			result.add(delta);
		}

		return (IModuleResourceDelta[]) result.toArray(new IModuleResourceDelta[result.size()]);
		list.toArray(delta);
		return delta;
	}

	protected boolean hasDelta(IModule[] module) {

	}

	protected boolean hasDelta(IModuleResource[] original, IModuleResource[] current) {
		if (original == null || current == null) {
			// TODO does not make sense if either is not null
			return false;
	
		// look for duplicates
		List found = new ArrayList();
		int size = original.length;
		int size2 = current.length;
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < size2; j++) {
				if (!found.contains(original[i]) && !found.contains(current[j]) && original[i].equals(current[j])) {
					// found a match
					found.add(original[i]);
					if (original[i] instanceof IModuleFile) {
						// include files only if the modification stamp has changed
						IModuleFile mf1 = (IModuleFile) original[i];
						IModuleFile mf2 = (IModuleFile) current[j];
						if (mf1.getModificationStamp() != mf2.getModificationStamp())
							return true;
					} else {
						// include folders only if their contents have changed
						IModuleFolder mf1 = (IModuleFolder) original[i];
						IModuleFolder mf2 = (IModuleFolder) current[j];
						IModuleResourceDelta[] mrdc = getDelta(mf1.members(), mf2.members());
						if (mrdc.length > 0)
							return true;
					}
				}
			}
		}

		// 
		Map originalMap = new HashMap();
		for (int i = 0; i < original.length; i++) {
			originalMap.put(original[i], original[i]);
			}
		}

		// added and changed resources
		for (int i = 0; i < current.length; i++) {
			// HashMap#remove is as fast as #get, right?
			IModuleResource old = (IModuleResource) originalMap.remove(current[i]);
			if (old == null) {
				return true;
			} else {
				if (current[i] instanceof IModuleFile) {
					// include files only if the modification stamp has changed
					IModuleFile mf1 = (IModuleFile) old;
					IModuleFile mf2 = (IModuleFile) current[i];
					if (mf1.getModificationStamp() != mf2.getModificationStamp()) {
						return true;
					}
				} else {
					// include folders only if their contents have changed
					IModuleFolder mf1 = (IModuleFolder) old;
					IModuleFolder mf2 = (IModuleFolder) current[i];
					return hasDelta(mf1.members(), mf2.members());
				}
			}
		}

		return !originalMap.isEmpty();
	}

	/**

Lines 62-67 Link Here

(-)servercore/org/eclipse/wst/server/core/internal/ModuleFile.java (+7 lines)
62	return true;	62	return true;
63	}	63	}
64		64
		65	public int hashCode() {
		66	int result = 37;
		67	result = 37 * result + name.hashCode();
		68	result = 37 * result + path.hashCode();
		69	return result;
		70	}
		71
65	public Object getAdapter(Class cl) {	72	public Object getAdapter(Class cl) {
66	if (IFile.class.equals(cl))	73	if (IFile.class.equals(cl))
67	return file;	74	return file;

Lines 67-72 Link Here

(-)servercore/org/eclipse/wst/server/core/internal/ModuleFolder.java (+7 lines)
67	return true;	67	return true;
68	}	68	}
69		69
		70	public int hashCode() {
		71	int result = 37;
		72	result = 37 * result + name.hashCode();
		73	result = 37 * result + path.hashCode();
		74	return result;
		75	}
		76
70	public Object getAdapter(Class cl) {	77	public Object getAdapter(Class cl) {
71	if (IContainer.class.equals(cl) \|\| IFolder.class.equals(cl))	78	if (IContainer.class.equals(cl) \|\| IFolder.class.equals(cl))
72	return container;	79	return container;

Return to bug 119146

Lines 224-298 Link Here

(-)servercore/org/eclipse/wst/server/core/internal/ServerPublishInfo.java (-100 / +79 lines)
224	}	224	}
225		225
226	protected IModuleResourceDelta[] getDelta(IModuleResource[] original, IModuleResource[] current) {	226	protected IModuleResourceDelta[] getDelta(IModuleResource[] original, IModuleResource[] current) {
227	if (original == null \|\| current == null)	227	if (original == null \|\| current == null) {
		228	// TODO does not make sense if either is not null
228	return new IModuleResourceDelta[0];	229	return new IModuleResourceDelta[0];
229
230	List list = new ArrayList();
231
232	// look for duplicates
233	List found = new ArrayList();
234	int size = original.length;
235	int size2 = current.length;
236	for (int i = 0; i < size; i++) {
237	for (int j = 0; j < size2; j++) {
238	if (!found.contains(original[i]) && !found.contains(current[j]) && original[i].equals(current[j])) {
239	// found a match
240	found.add(original[i]);
241	if (original[i] instanceof IModuleFile) {
242	// include files only if the modification stamp has changed
243	IModuleFile mf1 = (IModuleFile) original[i];
244	IModuleFile mf2 = (IModuleFile) current[j];
245	if (mf1.getModificationStamp() != mf2.getModificationStamp()) {
246	list.add(new ModuleResourceDelta(original[i], IModuleResourceDelta.CHANGED));
247	}
248	} else {
249	// include folders only if their contents have changed
250	IModuleFolder mf1 = (IModuleFolder) original[i];
251	IModuleFolder mf2 = (IModuleFolder) current[j];
252	IModuleResourceDelta[] mrdc = getDelta(mf1.members(), mf2.members());
253	if (mrdc.length > 0) {
254	ModuleResourceDelta mrd = new ModuleResourceDelta(original[i], IModuleResourceDelta.NO_CHANGE);
255	mrd.setChildren(mrdc);
256	list.add(mrd);
257	}
258	}
259	}
260	}
261	}	230	}
262		231
263	// add deletions (unfound items in the original list)	232	List result = new ArrayList();
264	for (int i = 0; i < size; i++) {	233
265	if (!found.contains(original[i])) {	234	//
266	if (original[i] instanceof IModuleFile) {	235	Map originalMap = new HashMap();
267	list.add(new ModuleResourceDelta(original[i], IModuleResourceDelta.REMOVED));	236	for (int i = 0; i < original.length; i++) {
		237	originalMap.put(original[i], original[i]);
		238	}
		239
		240	// added and changed resources
		241	for (int i = 0; i < current.length; i++) {
		242	// HashMap#remove is as fast as #get, right?
		243	IModuleResource old = (IModuleResource) originalMap.remove(current[i]);
		244	if (old == null) {
		245	ModuleResourceDelta delta = new ModuleResourceDelta(current[i], IModuleResourceDelta.ADDED);
		246	if (current[i] instanceof IModuleFolder) {
		247	IModuleFolder currentFolder = (IModuleFolder) current[i];
		248	delta.setChildren(getDeltaTree(currentFolder.members(), IModuleResourceDelta.ADDED));
		249	}
		250	result.add(delta);
		251	} else {
		252	if (current[i] instanceof IModuleFile) {
		253	// include files only if the modification stamp has changed
		254	IModuleFile mf1 = (IModuleFile) old;
		255	IModuleFile mf2 = (IModuleFile) current[i];
		256	if (mf1.getModificationStamp() != mf2.getModificationStamp()) {
		257	result.add(new ModuleResourceDelta(current[i], IModuleResourceDelta.CHANGED));
		258	}
268	} else {	259	} else {
269	IModuleFolder mf = (IModuleFolder) original[i];	260	// include folders only if their contents have changed
270	ModuleResourceDelta mrd = new ModuleResourceDelta(original[i], IModuleResourceDelta.REMOVED);	261	IModuleFolder mf1 = (IModuleFolder) old;
271	IModuleResourceDelta[] mrdc = getDeltaTree(mf.members(), IModuleResourceDelta.REMOVED);	262	IModuleFolder mf2 = (IModuleFolder) current[i];
272	mrd.setChildren(mrdc);	263	IModuleResourceDelta[] mrdc = getDelta(mf1.members(), mf2.members());
273	list.add(mrd);	264	if (mrdc.length > 0) {
		265	ModuleResourceDelta mrd = new ModuleResourceDelta(current[i], IModuleResourceDelta.NO_CHANGE);
		266	mrd.setChildren(mrdc);
		267	result.add(mrd);
		268	}
274	}	269	}
275	}	270	}
276	}	271	}
277		272
278	// add additions (unfound items in the current list)	273	// removed resources
279	for (int j = 0; j < size2; j++) {	274	for (int i = 0; i < original.length; i++) {
280	if (!found.contains(current[j])) {	275	if (!originalMap.containsKey(original[i])) continue;
281	if (current[j] instanceof IModuleFile) {	276	ModuleResourceDelta delta = new ModuleResourceDelta(original[i], IModuleResourceDelta.REMOVED);
282	list.add(new ModuleResourceDelta(current[j], IModuleResourceDelta.ADDED));	277	if (original[i] instanceof IModuleFolder) {
283	} else {	278	IModuleFolder removedFolder = (IModuleFolder) original[i];
284	IModuleFolder mf = (IModuleFolder) current[j];	279	delta.setChildren(getDeltaTree(removedFolder.members(), IModuleResourceDelta.REMOVED));
285	ModuleResourceDelta mrd = new ModuleResourceDelta(current[j], IModuleResourceDelta.ADDED);
286	IModuleResourceDelta[] mrdc = getDeltaTree(mf.members(), IModuleResourceDelta.ADDED);
287	mrd.setChildren(mrdc);
288	list.add(mrd);
289	}
290	}	280	}
		281	result.add(delta);
291	}	282	}
292		283
293	IModuleResourceDelta[] delta = new IModuleResourceDelta[list.size()];	284	return (IModuleResourceDelta[]) result.toArray(new IModuleResourceDelta[result.size()]);
294	list.toArray(delta);
295	return delta;
296	}	285	}
297		286
298	protected boolean hasDelta(IModule[] module) {	287	protected boolean hasDelta(IModule[] module) {
Lines 315-365 Link Here
315	}	304	}
316		305
317	protected boolean hasDelta(IModuleResource[] original, IModuleResource[] current) {	306	protected boolean hasDelta(IModuleResource[] original, IModuleResource[] current) {
318	if (original == null \|\| current == null)	307	if (original == null \|\| current == null) {
		308	// TODO does not make sense if either is not null
319	return false;	309	return false;
320
321	// look for duplicates
322	List found = new ArrayList();
323	int size = original.length;
324	int size2 = current.length;
325	for (int i = 0; i < size; i++) {
326	for (int j = 0; j < size2; j++) {
327	if (!found.contains(original[i]) && !found.contains(current[j]) && original[i].equals(current[j])) {
328	// found a match
329	found.add(original[i]);
330	if (original[i] instanceof IModuleFile) {
331	// include files only if the modification stamp has changed
332	IModuleFile mf1 = (IModuleFile) original[i];
333	IModuleFile mf2 = (IModuleFile) current[j];
334	if (mf1.getModificationStamp() != mf2.getModificationStamp())
335	return true;
336	} else {
337	// include folders only if their contents have changed
338	IModuleFolder mf1 = (IModuleFolder) original[i];
339	IModuleFolder mf2 = (IModuleFolder) current[j];
340	IModuleResourceDelta[] mrdc = getDelta(mf1.members(), mf2.members());
341	if (mrdc.length > 0)
342	return true;
343	}
344	}
345	}
346	}	310	}
347		311
348	// add deletions (unfound items in the original list)	312	//
349	for (int i = 0; i < size; i++) {	313	Map originalMap = new HashMap();
350	if (!found.contains(original[i])) {	314	for (int i = 0; i < original.length; i++) {
351	return true;	315	originalMap.put(original[i], original[i]);
352	}
353	}	316	}
354		317
355	// add additions (unfound items in the current list)	318	// added and changed resources
356	for (int j = 0; j < size2; j++) {	319	for (int i = 0; i < current.length; i++) {
357	if (!found.contains(current[j])) {	320	// HashMap#remove is as fast as #get, right?
		321	IModuleResource old = (IModuleResource) originalMap.remove(current[i]);
		322	if (old == null) {
358	return true;	323	return true;
		324	} else {
		325	if (current[i] instanceof IModuleFile) {
		326	// include files only if the modification stamp has changed
		327	IModuleFile mf1 = (IModuleFile) old;
		328	IModuleFile mf2 = (IModuleFile) current[i];
		329	if (mf1.getModificationStamp() != mf2.getModificationStamp()) {
		330	return true;
		331	}
		332	} else {
		333	// include folders only if their contents have changed
		334	IModuleFolder mf1 = (IModuleFolder) old;
		335	IModuleFolder mf2 = (IModuleFolder) current[i];
		336	return hasDelta(mf1.members(), mf2.members());
		337	}
359	}	338	}
360	}	339	}
361		340
362	return false;	341	return !originalMap.isEmpty();
363	}	342	}
364		343
365	/**	344	/**