r/org.eclipse.statet.ide.ui/srcECommons/org/eclipse/statet/ecommons/workbench/search/ui/ExtTextSearchResult.java - statet/org.eclipse.statet-r - Git at Google

 /*=============================================================================#
  # Copyright (c) 2013, 2019 Stephan Wahlbrink and others.
  #
  # This program and the accompanying materials are made available under the
  # terms of the Eclipse Public License 2.0 which is available at
  # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
  # which is available at https://www.apache.org/licenses/LICENSE-2.0.
  #
  # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
  #
  # Contributors:
  #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
  #=============================================================================*/

 package org.eclipse.statet.ecommons.workbench.search.ui;

 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.search.ui.ISearchResult;
 import org.eclipse.search.ui.ISearchResultListener;
 import org.eclipse.search.ui.SearchResultEvent;
 import org.eclipse.search.ui.text.AbstractTextSearchResult;
 import org.eclipse.search.ui.text.IEditorMatchAdapter;
 import org.eclipse.search.ui.text.IFileMatchAdapter;
 import org.eclipse.search.ui.text.Match;
 import org.eclipse.search.ui.text.MatchEvent;
 import org.eclipse.search.ui.text.RemoveAllEvent;

 import org.eclipse.statet.jcommons.collections.SortedArraySet;
 import org.eclipse.statet.jcommons.collections.SortedListSet;

 import org.eclipse.statet.ecommons.collections.FastList;


 /**
  *
  *
  * @param <E> element type
  * @param <M> match type
  */
 public abstract class ExtTextSearchResult<E, M extends Match> extends AbstractTextSearchResult {


 	private static class ChangeEvent extends MatchEvent {

 		private static final long serialVersionUID= -5266244762347509979L;

 		public ChangeEvent(final ISearchResult searchResult) {
 			super(searchResult);
 		}

 		@Override
 		protected void setKind(final int kind) {
 			super.setKind(kind);
 		}

 		@Override
 		protected void setMatch(final Match match) {
 			super.setMatch(match);
 		}

 		@Override
 		protected void setMatches(final Match[] matches) {
 			super.setMatches(matches);
 		}

 	}

 	protected static class DefaultMatchComparator<M extends Match> implements Comparator<M> {

 		public DefaultMatchComparator() {
 		}

 		@Override
 		public int compare(final M o1, final M o2) {
 			final int d= o1.getOffset() - o2.getOffset();
 			if (d != 0) {
 				return d;
 			}
 			return o1.getLength() - o2.getLength();
 		}

 	}


 	/* Locking:
 	 *   - All write changes => events are thrown in correct order:
 	 *         synchronized (this)
 	 *   - All access to toplevel collections {@link #elementMatches} and {@link #elementList}:
 	 *         synchronized (this.elementMatches)
 	 *   - All access to match lists, values of {@link #elementMatches}:
 	 *         synchronized (matches)
 	 */

 	private final ElementMatchComparator<E, M> comparator;

 	private final SortedListSet<E> elementList;
 	private final Map<E, SortedListSet<M>> elementMatches;

 	private final FastList<ISearchResultListener> listeners= new FastList<>(ISearchResultListener.class, FastList.IDENTITY);
 	private final ChangeEvent changeEvent= new ChangeEvent(this);


 	public ExtTextSearchResult(final ElementMatchComparator<E, M> comparator) {
 		this.comparator= comparator;

 		this.elementList= new SortedArraySet<>(comparator.getElement0(), comparator.getElementComparator());
 		this.elementMatches= new HashMap<>();
 	}


 	public ElementMatchComparator<E, M> getComparator() {
 		return this.comparator;
 	}

 	@Override
 	public String getTooltip() {
 		return getLabel();
 	}

 	@Override
 	public IEditorMatchAdapter getEditorMatchAdapter() {
 		return null;
 	}

 	@Override
 	public IFileMatchAdapter getFileMatchAdapter() {
 		return null;
 	}


 	@Override
 	public void addListener(final ISearchResultListener l) {
 		this.listeners.add(l);
 	}

 	@Override
 	public void removeListener(final ISearchResultListener l) {
 		this.listeners.remove(l);
 	}

 	protected ChangeEvent getChangeEvent(final int eventKind, final Match match) {
 		this.changeEvent.setKind(eventKind);
 		this.changeEvent.setMatch(match);
 		return this.changeEvent;
 	}

 	protected ChangeEvent getChangeEvent(final int eventKind, final List<Match> matches) {
 		this.changeEvent.setKind(eventKind);
 		this.changeEvent.setMatches(matches.toArray(new Match[matches.size()]));
 		return this.changeEvent;
 	}

 	@Override
 	protected void fireChange(final SearchResultEvent e) {
 		final ISearchResultListener[] listeners= this.listeners.toArray();
 		for (final ISearchResultListener listener : listeners) {
 			listener.searchResultChanged(e);
 		}
 	}


 	public int getElementCount() {
 		synchronized (this.elementMatches) {
 			return this.elementList.size();
 		}
 	}

 	@Override
 	public E[] getElements() {
 		synchronized (this.elementMatches) {
 			return this.elementList.toArray(this.comparator.getElement0());
 		}
 	}


 	@Override
 	public synchronized void addMatch(final Match match) {
 		final boolean done;
 		synchronized (this.elementMatches) {
 			done= doAddMatch((M) match);
 		}
 		if (done) {
 			fireChange(getChangeEvent(MatchEvent.ADDED, match));
 		}
 	}

 	@Override
 	public synchronized void addMatches(final Match[] matches) {
 		final List<Match> added= new ArrayList<>(matches.length);
 		synchronized (this.elementMatches) {
 			for (int i= 0; i < matches.length; i++) {
 				if (doAddMatch((M) matches[i])) {
 					added.add(matches[i]);
 				}
 			}
 		}
 		if (!added.isEmpty()) {
 			fireChange(getChangeEvent(MatchEvent.ADDED, added));
 		}
 	}

 	protected boolean doAddMatch(final M match) {
 		final E element= (E) match.getElement();
 		if (element == null) {
 			return false;
 		}
 		SortedListSet<M> matches= this.elementMatches.get(element);
 		if (matches == null) {
 			if (this.elementList.addE(element) < 0) {
 				return false;
 			}
 			matches= new SortedArraySet<>(this.comparator.getMatch0(), this.comparator.getMatchComparator());
 			this.elementMatches.put(element, matches);
 		}
 		synchronized (matches) {
 			if (matches.addE(match) >= 0) {
 				return true;
 			}
 		}
 		return false;
 	}

 	@Override
 	public synchronized void removeMatch(final Match match) {
 		final boolean done;
 		synchronized (this.elementMatches) {
 			done= doRemoveMatch((M) match);
 		}
 		if (done) {
 			fireChange(getChangeEvent(MatchEvent.REMOVED, match));
 		}
 	}

 	@Override
 	public synchronized void removeMatches(final Match[] matches) {
 		final List<Match> removed= new ArrayList<>(matches.length);
 		synchronized (this.elementMatches) {
 			for (int i= 0; i < matches.length; i++) {
 				if (doRemoveMatch((M) matches[i])) {
 					removed.add(matches[i]);
 				}
 			}
 		}
 		if (!removed.isEmpty()) {
 			fireChange(getChangeEvent(MatchEvent.REMOVED, removed));
 		}
 	}

 	protected boolean doRemoveMatch(final M match) {
 		final E element= (E) match.getElement();
 		if (element == null) {
 			return false;
 		}
 		final SortedListSet<M> matches= this.elementMatches.get(element);
 		if (matches == null) {
 			return false;
 		}
 		synchronized (matches) {
 			if (matches.removeE(match) < 0) {
 				return false;
 			}
 		}
 		if (matches.isEmpty()) {
 			this.elementList.remove(element);
 			this.elementMatches.remove(element);
 		}
 		return true;
 	}

 	@Override
 	public synchronized void removeAll() {
 		synchronized (this.elementMatches) {
 			doRemoveAll();
 		}
 		fireChange(new RemoveAllEvent(this));
 	}

 	protected void doRemoveAll() {
 		this.elementList.clear();
 		this.elementMatches.clear();
 	}

 	@Override
 	public int getMatchCount() {
 		synchronized (this.elementMatches) {
 			int count= 0;
 			for (final List<M> matches : this.elementMatches.values()) {
 				count+= matches.size();
 			}
 			return count;
 		}
 	}

 	public boolean hasMatches(final Object element) {
 		synchronized (this.elementMatches) {
 			return this.elementMatches.containsKey(element);
 		}
 	}

 	public boolean hasPickedMatches(final Object element) {
 		final SortedListSet<M> matches;
 		synchronized (this.elementMatches) {
 			matches= this.elementMatches.get(element);
 		}
 		if (matches != null) {
 			if (getActiveMatchFilters() == null) {
 				return true;
 			}
 			else {
 				synchronized (matches) {
 					for (final M match : matches) {
 						if (!match.isFiltered()) {
 							return true;
 						}
 					}
 				}
 			}
 		}
 		return false;
 	}

 	@Override
 	public int getMatchCount(final Object element) {
 		synchronized (this.elementMatches) {
 			final SortedListSet<M> matches= this.elementMatches.get(element);
 			if (matches != null) {
 				return matches.size();
 			}
 			return 0;
 		}
 	}

 	public int getPickedMatchCount(final Object element) {
 		final SortedListSet<M> matches;
 		synchronized (this.elementMatches) {
 			matches= this.elementMatches.get(element);
 		}
 		if (matches != null) {
 			if (getActiveMatchFilters() == null) {
 				synchronized (matches) {
 					return matches.size();
 				}
 			}
 			else {
 				synchronized (matches) {
 					int count= 0;
 					for (final M match : matches) {
 						if (!match.isFiltered()) {
 							count++;
 						}
 					}
 					return count;
 				}
 			}
 		}
 		return 0;
 	}

 	@Override
 	public M[] getMatches(final Object element) {
 		synchronized (this.elementMatches) {
 			final SortedListSet<M> matches= this.elementMatches.get(element);
 			if (matches != null) {
 				return matches.toArray(this.comparator.getMatch0());
 			}
 			return this.comparator.getMatch0();
 		}
 	}

 	public M[] getPickedMatches(final Object element) {
 		final SortedListSet<M> matches;
 		synchronized (this.elementMatches) {
 			matches= this.elementMatches.get(element);
 		}
 		if (matches != null) {
 			if (getActiveMatchFilters() == null) {
 				synchronized (matches) {
 					return matches.toArray(this.comparator.getMatch0());
 				}
 			}
 			else {
 				synchronized (matches) {
 					final List<M> filtered= new ArrayList<>(matches.size());
 					for (final M match : matches) {
 						if (!match.isFiltered()) {
 							filtered.add(match);
 						}
 					}
 					return filtered.toArray(this.comparator.getMatch0());
 				}
 			}
 		}
 		return this.comparator.getMatch0();
 	}

 }
	/*=============================================================================#
	# Copyright (c) 2013, 2019 Stephan Wahlbrink and others.
	#
	# This program and the accompanying materials are made available under the
	# terms of the Eclipse Public License 2.0 which is available at
	# https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
	# which is available at https://www.apache.org/licenses/LICENSE-2.0.
	#
	# SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
	#
	# Contributors:
	# Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
	#=============================================================================*/

	package org.eclipse.statet.ecommons.workbench.search.ui;

	import java.util.ArrayList;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.search.ui.ISearchResult;
	import org.eclipse.search.ui.ISearchResultListener;
	import org.eclipse.search.ui.SearchResultEvent;
	import org.eclipse.search.ui.text.AbstractTextSearchResult;
	import org.eclipse.search.ui.text.IEditorMatchAdapter;
	import org.eclipse.search.ui.text.IFileMatchAdapter;
	import org.eclipse.search.ui.text.Match;
	import org.eclipse.search.ui.text.MatchEvent;
	import org.eclipse.search.ui.text.RemoveAllEvent;

	import org.eclipse.statet.jcommons.collections.SortedArraySet;
	import org.eclipse.statet.jcommons.collections.SortedListSet;

	import org.eclipse.statet.ecommons.collections.FastList;


	/**
	*
	*
	* @param <E> element type
	* @param <M> match type
	*/
	public abstract class ExtTextSearchResult<E, M extends Match> extends AbstractTextSearchResult {


	private static class ChangeEvent extends MatchEvent {

	private static final long serialVersionUID= -5266244762347509979L;

	public ChangeEvent(final ISearchResult searchResult) {
	super(searchResult);
	}

	@Override
	protected void setKind(final int kind) {
	super.setKind(kind);
	}

	@Override
	protected void setMatch(final Match match) {
	super.setMatch(match);
	}

	@Override
	protected void setMatches(final Match[] matches) {
	super.setMatches(matches);
	}

	}

	protected static class DefaultMatchComparator<M extends Match> implements Comparator<M> {

	public DefaultMatchComparator() {
	}

	@Override
	public int compare(final M o1, final M o2) {
	final int d= o1.getOffset() - o2.getOffset();
	if (d != 0) {
	return d;
	}
	return o1.getLength() - o2.getLength();
	}

	}


	/* Locking:
	* - All write changes => events are thrown in correct order:
	* synchronized (this)
	* - All access to toplevel collections {@link #elementMatches} and {@link #elementList}:
	* synchronized (this.elementMatches)
	* - All access to match lists, values of {@link #elementMatches}:
	* synchronized (matches)
	*/

	private final ElementMatchComparator<E, M> comparator;

	private final SortedListSet<E> elementList;
	private final Map<E, SortedListSet<M>> elementMatches;

	private final FastList<ISearchResultListener> listeners= new FastList<>(ISearchResultListener.class, FastList.IDENTITY);
	private final ChangeEvent changeEvent= new ChangeEvent(this);


	public ExtTextSearchResult(final ElementMatchComparator<E, M> comparator) {
	this.comparator= comparator;

	this.elementList= new SortedArraySet<>(comparator.getElement0(), comparator.getElementComparator());
	this.elementMatches= new HashMap<>();
	}


	public ElementMatchComparator<E, M> getComparator() {
	return this.comparator;
	}

	@Override
	public String getTooltip() {
	return getLabel();
	}

	@Override
	public IEditorMatchAdapter getEditorMatchAdapter() {
	return null;
	}

	@Override
	public IFileMatchAdapter getFileMatchAdapter() {
	return null;
	}


	@Override
	public void addListener(final ISearchResultListener l) {
	this.listeners.add(l);
	}

	@Override
	public void removeListener(final ISearchResultListener l) {
	this.listeners.remove(l);
	}

	protected ChangeEvent getChangeEvent(final int eventKind, final Match match) {
	this.changeEvent.setKind(eventKind);
	this.changeEvent.setMatch(match);
	return this.changeEvent;
	}

	protected ChangeEvent getChangeEvent(final int eventKind, final List<Match> matches) {
	this.changeEvent.setKind(eventKind);
	this.changeEvent.setMatches(matches.toArray(new Match[matches.size()]));
	return this.changeEvent;
	}

	@Override
	protected void fireChange(final SearchResultEvent e) {
	final ISearchResultListener[] listeners= this.listeners.toArray();
	for (final ISearchResultListener listener : listeners) {
	listener.searchResultChanged(e);
	}
	}


	public int getElementCount() {
	synchronized (this.elementMatches) {
	return this.elementList.size();
	}
	}

	@Override
	public E[] getElements() {
	synchronized (this.elementMatches) {
	return this.elementList.toArray(this.comparator.getElement0());
	}
	}


	@Override
	public synchronized void addMatch(final Match match) {
	final boolean done;
	synchronized (this.elementMatches) {
	done= doAddMatch((M) match);
	}
	if (done) {
	fireChange(getChangeEvent(MatchEvent.ADDED, match));
	}
	}

	@Override
	public synchronized void addMatches(final Match[] matches) {
	final List<Match> added= new ArrayList<>(matches.length);
	synchronized (this.elementMatches) {
	for (int i= 0; i < matches.length; i++) {
	if (doAddMatch((M) matches[i])) {
	added.add(matches[i]);
	}
	}
	}
	if (!added.isEmpty()) {
	fireChange(getChangeEvent(MatchEvent.ADDED, added));
	}
	}

	protected boolean doAddMatch(final M match) {
	final E element= (E) match.getElement();
	if (element == null) {
	return false;
	}
	SortedListSet<M> matches= this.elementMatches.get(element);
	if (matches == null) {
	if (this.elementList.addE(element) < 0) {
	return false;
	}
	matches= new SortedArraySet<>(this.comparator.getMatch0(), this.comparator.getMatchComparator());
	this.elementMatches.put(element, matches);
	}
	synchronized (matches) {
	if (matches.addE(match) >= 0) {
	return true;
	}
	}
	return false;
	}

	@Override
	public synchronized void removeMatch(final Match match) {
	final boolean done;
	synchronized (this.elementMatches) {
	done= doRemoveMatch((M) match);
	}
	if (done) {
	fireChange(getChangeEvent(MatchEvent.REMOVED, match));
	}
	}

	@Override
	public synchronized void removeMatches(final Match[] matches) {
	final List<Match> removed= new ArrayList<>(matches.length);
	synchronized (this.elementMatches) {
	for (int i= 0; i < matches.length; i++) {
	if (doRemoveMatch((M) matches[i])) {
	removed.add(matches[i]);
	}
	}
	}
	if (!removed.isEmpty()) {
	fireChange(getChangeEvent(MatchEvent.REMOVED, removed));
	}
	}

	protected boolean doRemoveMatch(final M match) {
	final E element= (E) match.getElement();
	if (element == null) {
	return false;
	}
	final SortedListSet<M> matches= this.elementMatches.get(element);
	if (matches == null) {
	return false;
	}
	synchronized (matches) {
	if (matches.removeE(match) < 0) {
	return false;
	}
	}
	if (matches.isEmpty()) {
	this.elementList.remove(element);
	this.elementMatches.remove(element);
	}
	return true;
	}

	@Override
	public synchronized void removeAll() {
	synchronized (this.elementMatches) {
	doRemoveAll();
	}
	fireChange(new RemoveAllEvent(this));
	}

	protected void doRemoveAll() {
	this.elementList.clear();
	this.elementMatches.clear();
	}

	@Override
	public int getMatchCount() {
	synchronized (this.elementMatches) {
	int count= 0;
	for (final List<M> matches : this.elementMatches.values()) {
	count+= matches.size();
	}
	return count;
	}
	}

	public boolean hasMatches(final Object element) {
	synchronized (this.elementMatches) {
	return this.elementMatches.containsKey(element);
	}
	}

	public boolean hasPickedMatches(final Object element) {
	final SortedListSet<M> matches;
	synchronized (this.elementMatches) {
	matches= this.elementMatches.get(element);
	}
	if (matches != null) {
	if (getActiveMatchFilters() == null) {
	return true;
	}
	else {
	synchronized (matches) {
	for (final M match : matches) {
	if (!match.isFiltered()) {
	return true;
	}
	}
	}
	}
	}
	return false;
	}

	@Override
	public int getMatchCount(final Object element) {
	synchronized (this.elementMatches) {
	final SortedListSet<M> matches= this.elementMatches.get(element);
	if (matches != null) {
	return matches.size();
	}
	return 0;
	}
	}

	public int getPickedMatchCount(final Object element) {
	final SortedListSet<M> matches;
	synchronized (this.elementMatches) {
	matches= this.elementMatches.get(element);
	}
	if (matches != null) {
	if (getActiveMatchFilters() == null) {
	synchronized (matches) {
	return matches.size();
	}
	}
	else {
	synchronized (matches) {
	int count= 0;
	for (final M match : matches) {
	if (!match.isFiltered()) {
	count++;
	}
	}
	return count;
	}
	}
	}
	return 0;
	}

	@Override
	public M[] getMatches(final Object element) {
	synchronized (this.elementMatches) {
	final SortedListSet<M> matches= this.elementMatches.get(element);
	if (matches != null) {
	return matches.toArray(this.comparator.getMatch0());
	}
	return this.comparator.getMatch0();
	}
	}

	public M[] getPickedMatches(final Object element) {
	final SortedListSet<M> matches;
	synchronized (this.elementMatches) {
	matches= this.elementMatches.get(element);
	}
	if (matches != null) {
	if (getActiveMatchFilters() == null) {
	synchronized (matches) {
	return matches.toArray(this.comparator.getMatch0());
	}
	}
	else {
	synchronized (matches) {
	final List<M> filtered= new ArrayList<>(matches.size());
	for (final M match : matches) {
	if (!match.isFiltered()) {
	filtered.add(match);
	}
	}
	return filtered.toArray(this.comparator.getMatch0());
	}
	}
	}
	return this.comparator.getMatch0();
	}

	}