Attachment 55405 Details for Bug 167436 – random stuff

[patch] random stuff

patch-167436.txt (text/plain), 11.71 KB, created by Boris Bokowski

on 2006-12-11 10:30:31 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Boris Bokowski

Created: 2006-12-11 10:30:31 EST

Size: 11.71 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.core.databinding
>Index: src/org/eclipse/core/databinding/util/IFilter.java
>===================================================================
>RCS file: src/org/eclipse/core/databinding/util/IFilter.java
>diff -N src/org/eclipse/core/databinding/util/IFilter.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/core/databinding/util/IFilter.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,27 @@
>+/*******************************************************************************
>+ * Copyright (c) 2004, 2006 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.core.databinding.util;
>+
>+/**
>+ * Interface for filters. Can accept or reject items.
>+ * 
>+ * @since 1.0
>+ */
>+public interface IFilter {
>+	/**
>+	 * Determines if the given object passes this filter.
>+	 * 
>+	 * @param toTest object to compare against the filter 
>+	 * 
>+	 * @return true iff the object is accepted by the filter.
>+	 */
>+	public boolean select(Object toTest);
>+}
>Index: src/org/eclipse/core/databinding/observable/set/FilteringSet.java
>===================================================================
>RCS file: src/org/eclipse/core/databinding/observable/set/FilteringSet.java
>diff -N src/org/eclipse/core/databinding/observable/set/FilteringSet.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/core/databinding/observable/set/FilteringSet.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,155 @@
>+/*******************************************************************************
>+ * Copyright (c) 2006 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.core.databinding.observable.set;
>+
>+import java.util.Collections;
>+import java.util.HashSet;
>+import java.util.Iterator;
>+import java.util.Set;
>+
>+import org.eclipse.core.databinding.observable.Diffs;
>+import org.eclipse.core.databinding.util.IFilter;
>+import org.eclipse.core.runtime.Assert;
>+import org.eclipse.core.runtime.IProgressMonitor;
>+
>+/**
>+ * @since 3.3
>+ * 
>+ */
>+public abstract class FilteringSet extends ObservableSet {
>+
>+	private IObservableSet set;
>+
>+	private IFilter filter;
>+
>+	private ISetChangeListener setChangeListener = new ISetChangeListener() {
>+		public void handleSetChange(IObservableSet source, SetDiff diff) {
>+			if (filter == null) {
>+				fireSetChange(diff);
>+				return;
>+			}
>+			Set removals = new HashSet();
>+			Set additions = new HashSet();
>+			for (Iterator it = diff.getRemovals().iterator(); it.hasNext();) {
>+				Object removedElement = it.next();
>+				if (filter.select(removedElement)) {
>+					wrappedSet.remove(removedElement);
>+					removals.add(removedElement);
>+				}
>+			}
>+			for (Iterator it = diff.getAdditions().iterator(); it.hasNext();) {
>+				Object addedElement = it.next();
>+				if (filter.select(addedElement)) {
>+					wrappedSet.add(addedElement);
>+					additions.add(addedElement);
>+				}
>+			}
>+			fireSetChange(Diffs.createSetDiff(additions, removals));
>+		}
>+	};
>+
>+	/**
>+	 * @param set
>+	 */
>+	public FilteringSet(IObservableSet set) {
>+		super(set.getRealm(), set, set.getElementType());
>+		this.set = set;
>+		set.addSetChangeListener(setChangeListener);
>+	}
>+
>+	/**
>+	 * @param filter
>+	 * @param monitor
>+	 * @param incrementalEvents
>+	 */
>+	public void init(IFilter filter, IProgressMonitor monitor,
>+			boolean incrementalEvents) {
>+		Assert.isTrue(this.filter == null);
>+		Assert.isTrue(filter != null);
>+		wrappedSet = new HashSet(set);
>+		this.filter = filter;
>+		refilter(monitor, incrementalEvents, true);
>+	}
>+
>+	/**
>+	 * Clients should call this method to cause the elements to be refiltered
>+	 * after a change to the filter criteria.
>+	 * 
>+	 * @param monitor
>+	 *            progress monitor for reporting progress and cancellation
>+	 * @param incrementalEvents
>+	 *            <code>true</code> if change events should be fired
>+	 *            incrementally, <code>false</code> if just one combined
>+	 *            change event at the end should be fired
>+	 * @param narrowing
>+	 *            <code>true</code> if the result of the refilter will be a
>+	 *            subset of the current set
>+	 * 
>+	 */
>+	public void refilter(IProgressMonitor monitor, boolean incrementalEvents,
>+			boolean narrowing) {
>+		setStale(true);
>+		monitor.beginTask("NON-NLSed: Filtering", set.size()); //$NON-NLS-1$
>+		Set additions = new HashSet();
>+		Set removals = new HashSet();
>+		// Delay firing of incremental events by one iteration so that we have
>+		// one event left at the end. This allows us to call setStale(false)
>+		// before firing the last event.
>+		SetDiff nextDiff = null;
>+		Iterator it = narrowing ? wrappedSet.iterator() : set.iterator();
>+		while (!monitor.isCanceled() && it.hasNext()) {
>+			Object element = it.next();
>+			if (filter == null || filter.select(element)) {
>+				if (!narrowing && wrappedSet.add(element)) {
>+					if (incrementalEvents) {
>+						if (nextDiff != null) {
>+							fireSetChange(nextDiff);
>+						}
>+						nextDiff = Diffs.createSetDiff(Collections
>+								.singleton(element), Collections.EMPTY_SET);
>+					} else {
>+						additions.add(element);
>+					}
>+				}
>+			} else {
>+				if (wrappedSet.remove(element)) {
>+					if (incrementalEvents) {
>+						if (nextDiff != null) {
>+							fireSetChange(nextDiff);
>+						}
>+						nextDiff = Diffs.createSetDiff(Collections.EMPTY_SET,
>+								Collections.singleton(element));
>+					} else {
>+						removals.add(element);
>+					}
>+				}
>+			}
>+			monitor.worked(1);
>+		}
>+		setStale(false);
>+		if (incrementalEvents) {
>+			if (nextDiff != null) {
>+				fireSetChange(nextDiff);
>+			} else {
>+				// This is needed in order to notify clients that track
>+				// staleness.
>+				fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,
>+						Collections.EMPTY_SET));
>+			}
>+		} else {
>+			SetDiff diff = Diffs.createSetDiff(additions, removals);
>+			fireSetChange(diff);
>+		}
>+		monitor.done();
>+	}
>+
>+}
>Index: src/org/eclipse/core/databinding/observable/list/FilteringList.java
>===================================================================
>RCS file: src/org/eclipse/core/databinding/observable/list/FilteringList.java
>diff -N src/org/eclipse/core/databinding/observable/list/FilteringList.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/core/databinding/observable/list/FilteringList.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,142 @@
>+package org.eclipse.core.databinding.observable.list;
>+
>+import java.util.ArrayList;
>+import java.util.Arrays;
>+import java.util.List;
>+
>+import org.eclipse.core.databinding.observable.Diffs;
>+import org.eclipse.core.databinding.observable.value.IObservableValue;
>+
>+/**
>+ * @since 1.0
>+ * 
>+ */
>+public abstract class FilteringList extends ObservableList {
>+
>+	private final IObservableList unfiltered;
>+
>+	private final IObservableValue textObservable;
>+
>+	private IListChangeListener listChangeListener = new IListChangeListener() {
>+		public void handleListChange(IObservableList source, ListDiff diff) {
>+			ListDiffEntry[] differences = diff.getDifferences();
>+			List listDiffEntries = new ArrayList();
>+			for (int i = 0; i < differences.length; i++) {
>+				ListDiffEntry diffEntry = differences[i];
>+				Object element = diffEntry.getElement();
>+				if (diffEntry.isAddition()) {
>+					if (select(element)) {
>+						int index = internalAddElement(element, diffEntry
>+								.getPosition());
>+						if (index >= 0) {
>+							listDiffEntries.add(Diffs.createListDiffEntry(
>+									index, true, element));
>+						}
>+					}
>+				} else {
>+					if (select(element)) {
>+						int index = internalRemoveElement(element, diffEntry
>+								.getPosition());
>+						if (index >= 0) {
>+							listDiffEntries.add(Diffs.createListDiffEntry(
>+									index, false, element));
>+						}
>+					}
>+				}
>+			}
>+			fireListChange(Diffs
>+					.createListDiff((ListDiffEntry[]) listDiffEntries
>+							.toArray(new ListDiffEntry[listDiffEntries.size()])));
>+		}
>+	};
>+
>+	protected FilteringList(IObservableList list,
>+			IObservableValue textObservable) {
>+		super(list.getRealm(), new ArrayList(), list.getElementType());
>+		this.unfiltered = list;
>+		unfiltered.addListChangeListener(listChangeListener);
>+		refilter();
>+	}
>+
>+	protected void refilter() {
>+		List listDiffEntries = new ArrayList();
>+		for (int i = 0; i < unfiltered.size(); i++) {
>+			Object element = unfiltered.get(i);
>+			if (select(element)) {
>+				int newIndex = internalAddElement(element, i);
>+				if (newIndex >= 0) {
>+					listDiffEntries.add(Diffs.createListDiffEntry(newIndex,
>+							true, element));
>+				}
>+			} else {
>+				int oldIndex = internalRemoveElement(element, i);
>+				if (oldIndex >= 0) {
>+					listDiffEntries.add(Diffs.createListDiffEntry(oldIndex,
>+							false, element));
>+				}
>+			}
>+		}
>+		fireListChange(Diffs.createListDiff((ListDiffEntry[]) listDiffEntries
>+				.toArray(new ListDiffEntry[listDiffEntries.size()])));
>+	}
>+
>+	private int internalRemoveElement(Object element, int childIndex) {
>+		int location = Arrays.binarySearch(filteredIndices, childIndex);
>+		if (location >= 0) {
>+			wrappedList.remove(location);
>+			if (location == 0) {
>+				if (filteredIndices.length == 1) {
>+					filteredIndices = new int[0];
>+				} else {
>+					int[] next = new int[filteredIndices.length - 1];
>+					System.arraycopy(filteredIndices, 1, next, 0, next.length);
>+					filteredIndices = next;
>+				}
>+			} else if (location == (filteredIndices.length - 1)) {
>+				int[] next = new int[filteredIndices.length - 1];
>+				System.arraycopy(filteredIndices, 0, next, 0, location);
>+				filteredIndices = next;
>+			} else {
>+				int[] next = new int[filteredIndices.length - 1];
>+				System.arraycopy(filteredIndices, 0, next, 0, location);
>+				System.arraycopy(filteredIndices, location + 1, next, location,
>+						next.length - location);
>+				filteredIndices = next;
>+			}
>+		}
>+		return location;
>+	}
>+
>+	private int internalAddElement(Object element, int index) {
>+		int location = Arrays.binarySearch(filteredIndices, index);
>+		if (location >= 0) {
>+			return -1;
>+		}
>+		location = 0 - (location + 1);
>+		wrappedList.add(location, element);
>+		int[] next = new int[filteredIndices.length + 1];
>+		if (location == 0) {
>+			next[0] = index;
>+			System.arraycopy(filteredIndices, 0, next, 1,
>+					filteredIndices.length);
>+		} else if (location == filteredIndices.length) {
>+			next[filteredIndices.length] = index;
>+			System.arraycopy(filteredIndices, 0, next, 0,
>+					filteredIndices.length);
>+		} else {
>+			System.arraycopy(filteredIndices, 0, next, 0, location);
>+			next[location] = index;
>+			System.arraycopy(filteredIndices, location, next, location + 1,
>+					filteredIndices.length - location);
>+		}
>+		filteredIndices = next;
>+		return location;
>+	}
>+
>+	protected boolean select(Object element) {
>+		return stringMatcher.match(getText(element));
>+	}
>+
>+	protected abstract String getText(Object element);
>+
>+}

Actions: View | Diff

Attachments on bug 167436: 55405