/*******************************************************************************

 * 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);

}

/*******************************************************************************

 * 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();

	}

}

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);

}