org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/search/LevelTreeContentProvider.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2011 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
  *     Carsten Pfeiffer <carsten.pfeiffer@gebit.de> - [search] Custom search results not shown hierarchically in the java search results view - https://bugs.eclipse.org/bugs/show_bug.cgi?id=303705
  *******************************************************************************/

 package org.eclipse.jdt.internal.ui.search;

 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.core.runtime.IAdaptable;

 import org.eclipse.core.resources.IResource;

 import org.eclipse.jface.viewers.AbstractTreeViewer;
 import org.eclipse.jface.viewers.ITreeContentProvider;

 import org.eclipse.search.ui.text.AbstractTextSearchResult;

 import org.eclipse.jdt.core.IClassFile;
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IType;

 import org.eclipse.jdt.ui.StandardJavaElementContentProvider;

 public class LevelTreeContentProvider extends JavaSearchContentProvider implements ITreeContentProvider {
 	private Map<Object, Set<Object>> fChildrenMap;
 	private StandardJavaElementContentProvider fContentProvider;

 	public static final int LEVEL_TYPE= 1;
 	public static final int LEVEL_FILE= 2;
 	public static final int LEVEL_PACKAGE= 3;
 	public static final int LEVEL_PROJECT= 4;

 	private static final int[][] JAVA_ELEMENT_TYPES= {{IJavaElement.TYPE},
 			{IJavaElement.CLASS_FILE, IJavaElement.COMPILATION_UNIT},
 			{IJavaElement.PACKAGE_FRAGMENT},
 			{IJavaElement.JAVA_PROJECT, IJavaElement.PACKAGE_FRAGMENT_ROOT},
 			{IJavaElement.JAVA_MODEL}};
 	private static final int[][] RESOURCE_TYPES= {
 			{},
 			{IResource.FILE},
 			{IResource.FOLDER},
 			{IResource.PROJECT},
 			{IResource.ROOT}};

 	private static final int MAX_LEVEL= JAVA_ELEMENT_TYPES.length - 1;
 	private int fCurrentLevel;
 	static class FastJavaElementProvider extends StandardJavaElementContentProvider {
 		@Override
 		public Object getParent(Object element) {
 			Object parent= internalGetParent(element);
 			if (parent == null && element instanceof IAdaptable) {
 				IAdaptable adaptable = (IAdaptable)element;
 				Object javaElement= adaptable.getAdapter(IJavaElement.class);
 				if (javaElement != null) {
 					parent= internalGetParent(javaElement);
 				} else {
 					Object resource= adaptable.getAdapter(IResource.class);
 					if (resource != null) {
 						parent= internalGetParent(resource);
 					}
 				}
 			}
 			return parent;
 		}
 	}

 	public LevelTreeContentProvider(JavaSearchResultPage page, int level) {
 		super(page);
 		fCurrentLevel= level;
 		fContentProvider= new FastJavaElementProvider();
 	}

 	public Object getParent(Object child) {
 		Object possibleParent= internalGetParent(child);
 		if (possibleParent instanceof IJavaElement) {
 			IJavaElement javaElement= (IJavaElement) possibleParent;
 			for (int j= fCurrentLevel; j < MAX_LEVEL + 1; j++) {
 				for (int i= 0; i < JAVA_ELEMENT_TYPES[j].length; i++) {
 					if (javaElement.getElementType() == JAVA_ELEMENT_TYPES[j][i]) {
 						return null;
 					}
 				}
 			}
 		} else if (possibleParent instanceof IResource) {
 			IResource resource= (IResource) possibleParent;
 			for (int j= fCurrentLevel; j < MAX_LEVEL + 1; j++) {
 				for (int i= 0; i < RESOURCE_TYPES[j].length; i++) {
 					if (resource.getType() == RESOURCE_TYPES[j][i]) {
 						return null;
 					}
 				}
 			}
 		}
 		if (fCurrentLevel != LEVEL_FILE && child instanceof IType) {
 			IType type= (IType) child;
 			if (possibleParent instanceof ICompilationUnit
 					|| possibleParent instanceof IClassFile)
 				possibleParent= type.getPackageFragment();
 		}
 		return possibleParent;
 	}

 	private Object internalGetParent(Object child) {
 		return fContentProvider.getParent(child);
 	}

 	public Object[] getElements(Object inputElement) {
 		return getChildren(inputElement);
 	}

 	@Override
 	protected synchronized void initialize(AbstractTextSearchResult result) {
 		super.initialize(result);
 		fChildrenMap= new HashMap<Object, Set<Object>>();
 		if (result != null) {
 			Object[] elements= result.getElements();
 			for (int i= 0; i < elements.length; i++) {
 				if (getPage().getDisplayedMatchCount(elements[i]) > 0) {
 					insert(null, null, elements[i]);
 				}
 			}
 		}
 	}

 	protected void insert(Map<Object, Set<Object>> toAdd, Set<Object> toUpdate, Object child) {
 		Object parent= getParent(child);
 		while (parent != null) {
 			if (insertChild(parent, child)) {
 				if (toAdd != null)
 					insertInto(parent, child, toAdd);
 			} else {
 				if (toUpdate != null)
 					toUpdate.add(parent);
 				return;
 			}
 			child= parent;
 			parent= getParent(child);
 		}
 		if (insertChild(getSearchResult(), child)) {
 			if (toAdd != null)
 				insertInto(getSearchResult(), child, toAdd);
 		}
 	}

 	private boolean insertChild(Object parent, Object child) {
 		return insertInto(parent, child, fChildrenMap);
 	}

 	private boolean insertInto(Object parent, Object child, Map<Object, Set<Object>> map) {
 		Set<Object> children= map.get(parent);
 		if (children == null) {
 			children= new HashSet<Object>();
 			map.put(parent, children);
 		}
 		return children.add(child);
 	}

 	protected void remove(Set<Object> toRemove, Set<Object> toUpdate, Object element) {
 		// precondition here:  fResult.getMatchCount(child) <= 0

 		if (hasChildren(element)) {
 			if (toUpdate != null)
 				toUpdate.add(element);
 		} else {
 			if (getPage().getDisplayedMatchCount(element) == 0) {
 				fChildrenMap.remove(element);
 				Object parent= getParent(element);
 				if (parent != null) {
 					if (removeFromSiblings(element, parent)) {
 						remove(toRemove, toUpdate, parent);
 					}
 				} else {
 					if (removeFromSiblings(element, getSearchResult())) {
 						if (toRemove != null)
 							toRemove.add(element);
 					}
 				}
 			} else {
 				if (toUpdate != null) {
 					toUpdate.add(element);
 				}
 			}
 		}
 	}

 	/**
 	 * Tries to remove the given element from the list of stored siblings.
 	 *
 	 * @param element potential child
 	 * @param parent potential parent
 	 * @return returns true if it really was a remove (i.e. element was a child of parent).
 	 */
 	private boolean removeFromSiblings(Object element, Object parent) {
 		Set<Object> siblings= fChildrenMap.get(parent);
 		if (siblings != null) {
 			return siblings.remove(element);
 		} else {
 			return false;
 		}
 	}

 	public Object[] getChildren(Object parentElement) {
 		Set<Object> children= fChildrenMap.get(parentElement);
 		if (children == null)
 			return EMPTY_ARR;
 		int limit= getPage().getElementLimit().intValue();
 		if (limit != -1 && limit < children.size()) {
 			Object[] limitedArray= new Object[limit];
 			Iterator<Object> iterator= children.iterator();
 			for (int i= 0; i < limit; i++) {
 				limitedArray[i]= iterator.next();
 			}
 			return limitedArray;
 		}

 		return children.toArray();
 	}

 	public boolean hasChildren(Object element) {
 		Set<Object> children= fChildrenMap.get(element);
 		return children != null && !children.isEmpty();
 	}

 	@Override
 	public synchronized void elementsChanged(Object[] updatedElements) {
 		if (getSearchResult() == null)
 			return;

 		AbstractTreeViewer viewer= (AbstractTreeViewer) getPage().getViewer();

 		Set<Object> toRemove= new HashSet<Object>();
 		Set<Object> toUpdate= new HashSet<Object>();
 		Map<Object, Set<Object>> toAdd= new HashMap<Object, Set<Object>>();
 		for (int i= 0; i < updatedElements.length; i++) {
 			if (getPage().getDisplayedMatchCount(updatedElements[i]) > 0)
 				insert(toAdd, toUpdate, updatedElements[i]);
 			else
 				remove(toRemove, toUpdate, updatedElements[i]);
 		}

 		viewer.remove(toRemove.toArray());
 		for (Iterator<Object> iter= toAdd.keySet().iterator(); iter.hasNext();) {
 			Object parent= iter.next();
 			HashSet<Object> children= (HashSet<Object>) toAdd.get(parent);
 			viewer.add(parent, children.toArray());
 		}
 		for (Iterator<Object> elementsToUpdate= toUpdate.iterator(); elementsToUpdate.hasNext();) {
 			viewer.refresh(elementsToUpdate.next());
 		}

 	}

 	@Override
 	public void clear() {
 		initialize(getSearchResult());
 		getPage().getViewer().refresh();
 	}

 	public void setLevel(int level) {
 		fCurrentLevel= level;
 		initialize(getSearchResult());
 		getPage().getViewer().refresh();
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2000, 2011 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
	* Carsten Pfeiffer <carsten.pfeiffer@gebit.de> - [search] Custom search results not shown hierarchically in the java search results view - https://bugs.eclipse.org/bugs/show_bug.cgi?id=303705
	*******************************************************************************/

	package org.eclipse.jdt.internal.ui.search;

	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.core.runtime.IAdaptable;

	import org.eclipse.core.resources.IResource;

	import org.eclipse.jface.viewers.AbstractTreeViewer;
	import org.eclipse.jface.viewers.ITreeContentProvider;

	import org.eclipse.search.ui.text.AbstractTextSearchResult;

	import org.eclipse.jdt.core.IClassFile;
	import org.eclipse.jdt.core.ICompilationUnit;
	import org.eclipse.jdt.core.IJavaElement;
	import org.eclipse.jdt.core.IType;

	import org.eclipse.jdt.ui.StandardJavaElementContentProvider;

	public class LevelTreeContentProvider extends JavaSearchContentProvider implements ITreeContentProvider {
	private Map<Object, Set<Object>> fChildrenMap;
	private StandardJavaElementContentProvider fContentProvider;

	public static final int LEVEL_TYPE= 1;
	public static final int LEVEL_FILE= 2;
	public static final int LEVEL_PACKAGE= 3;
	public static final int LEVEL_PROJECT= 4;

	private static final int[][] JAVA_ELEMENT_TYPES= {{IJavaElement.TYPE},
	{IJavaElement.CLASS_FILE, IJavaElement.COMPILATION_UNIT},
	{IJavaElement.PACKAGE_FRAGMENT},
	{IJavaElement.JAVA_PROJECT, IJavaElement.PACKAGE_FRAGMENT_ROOT},
	{IJavaElement.JAVA_MODEL}};
	private static final int[][] RESOURCE_TYPES= {
	{},
	{IResource.FILE},
	{IResource.FOLDER},
	{IResource.PROJECT},
	{IResource.ROOT}};

	private static final int MAX_LEVEL= JAVA_ELEMENT_TYPES.length - 1;
	private int fCurrentLevel;
	static class FastJavaElementProvider extends StandardJavaElementContentProvider {
	@Override
	public Object getParent(Object element) {
	Object parent= internalGetParent(element);
	if (parent == null && element instanceof IAdaptable) {
	IAdaptable adaptable = (IAdaptable)element;
	Object javaElement= adaptable.getAdapter(IJavaElement.class);
	if (javaElement != null) {
	parent= internalGetParent(javaElement);
	} else {
	Object resource= adaptable.getAdapter(IResource.class);
	if (resource != null) {
	parent= internalGetParent(resource);
	}
	}
	}
	return parent;
	}
	}

	public LevelTreeContentProvider(JavaSearchResultPage page, int level) {
	super(page);
	fCurrentLevel= level;
	fContentProvider= new FastJavaElementProvider();
	}

	public Object getParent(Object child) {
	Object possibleParent= internalGetParent(child);
	if (possibleParent instanceof IJavaElement) {
	IJavaElement javaElement= (IJavaElement) possibleParent;
	for (int j= fCurrentLevel; j < MAX_LEVEL + 1; j++) {
	for (int i= 0; i < JAVA_ELEMENT_TYPES[j].length; i++) {
	if (javaElement.getElementType() == JAVA_ELEMENT_TYPES[j][i]) {
	return null;
	}
	}
	}
	} else if (possibleParent instanceof IResource) {
	IResource resource= (IResource) possibleParent;
	for (int j= fCurrentLevel; j < MAX_LEVEL + 1; j++) {
	for (int i= 0; i < RESOURCE_TYPES[j].length; i++) {
	if (resource.getType() == RESOURCE_TYPES[j][i]) {
	return null;
	}
	}
	}
	}
	if (fCurrentLevel != LEVEL_FILE && child instanceof IType) {
	IType type= (IType) child;
	if (possibleParent instanceof ICompilationUnit
	\|\| possibleParent instanceof IClassFile)
	possibleParent= type.getPackageFragment();
	}
	return possibleParent;
	}

	private Object internalGetParent(Object child) {
	return fContentProvider.getParent(child);
	}

	public Object[] getElements(Object inputElement) {
	return getChildren(inputElement);
	}

	@Override
	protected synchronized void initialize(AbstractTextSearchResult result) {
	super.initialize(result);
	fChildrenMap= new HashMap<Object, Set<Object>>();
	if (result != null) {
	Object[] elements= result.getElements();
	for (int i= 0; i < elements.length; i++) {
	if (getPage().getDisplayedMatchCount(elements[i]) > 0) {
	insert(null, null, elements[i]);
	}
	}
	}
	}

	protected void insert(Map<Object, Set<Object>> toAdd, Set<Object> toUpdate, Object child) {
	Object parent= getParent(child);
	while (parent != null) {
	if (insertChild(parent, child)) {
	if (toAdd != null)
	insertInto(parent, child, toAdd);
	} else {
	if (toUpdate != null)
	toUpdate.add(parent);
	return;
	}
	child= parent;
	parent= getParent(child);
	}
	if (insertChild(getSearchResult(), child)) {
	if (toAdd != null)
	insertInto(getSearchResult(), child, toAdd);
	}
	}

	private boolean insertChild(Object parent, Object child) {
	return insertInto(parent, child, fChildrenMap);
	}

	private boolean insertInto(Object parent, Object child, Map<Object, Set<Object>> map) {
	Set<Object> children= map.get(parent);
	if (children == null) {
	children= new HashSet<Object>();
	map.put(parent, children);
	}
	return children.add(child);
	}

	protected void remove(Set<Object> toRemove, Set<Object> toUpdate, Object element) {
	// precondition here: fResult.getMatchCount(child) <= 0

	if (hasChildren(element)) {
	if (toUpdate != null)
	toUpdate.add(element);
	} else {
	if (getPage().getDisplayedMatchCount(element) == 0) {
	fChildrenMap.remove(element);
	Object parent= getParent(element);
	if (parent != null) {
	if (removeFromSiblings(element, parent)) {
	remove(toRemove, toUpdate, parent);
	}
	} else {
	if (removeFromSiblings(element, getSearchResult())) {
	if (toRemove != null)
	toRemove.add(element);
	}
	}
	} else {
	if (toUpdate != null) {
	toUpdate.add(element);
	}
	}
	}
	}

	/**
	* Tries to remove the given element from the list of stored siblings.
	*
	* @param element potential child
	* @param parent potential parent
	* @return returns true if it really was a remove (i.e. element was a child of parent).
	*/
	private boolean removeFromSiblings(Object element, Object parent) {
	Set<Object> siblings= fChildrenMap.get(parent);
	if (siblings != null) {
	return siblings.remove(element);
	} else {
	return false;
	}
	}

	public Object[] getChildren(Object parentElement) {
	Set<Object> children= fChildrenMap.get(parentElement);
	if (children == null)
	return EMPTY_ARR;
	int limit= getPage().getElementLimit().intValue();
	if (limit != -1 && limit < children.size()) {
	Object[] limitedArray= new Object[limit];
	Iterator<Object> iterator= children.iterator();
	for (int i= 0; i < limit; i++) {
	limitedArray[i]= iterator.next();
	}
	return limitedArray;
	}

	return children.toArray();
	}

	public boolean hasChildren(Object element) {
	Set<Object> children= fChildrenMap.get(element);
	return children != null && !children.isEmpty();
	}

	@Override
	public synchronized void elementsChanged(Object[] updatedElements) {
	if (getSearchResult() == null)
	return;

	AbstractTreeViewer viewer= (AbstractTreeViewer) getPage().getViewer();

	Set<Object> toRemove= new HashSet<Object>();
	Set<Object> toUpdate= new HashSet<Object>();
	Map<Object, Set<Object>> toAdd= new HashMap<Object, Set<Object>>();
	for (int i= 0; i < updatedElements.length; i++) {
	if (getPage().getDisplayedMatchCount(updatedElements[i]) > 0)
	insert(toAdd, toUpdate, updatedElements[i]);
	else
	remove(toRemove, toUpdate, updatedElements[i]);
	}

	viewer.remove(toRemove.toArray());
	for (Iterator<Object> iter= toAdd.keySet().iterator(); iter.hasNext();) {
	Object parent= iter.next();
	HashSet<Object> children= (HashSet<Object>) toAdd.get(parent);
	viewer.add(parent, children.toArray());
	}
	for (Iterator<Object> elementsToUpdate= toUpdate.iterator(); elementsToUpdate.hasNext();) {
	viewer.refresh(elementsToUpdate.next());
	}

	}

	@Override
	public void clear() {
	initialize(getSearchResult());
	getPage().getViewer().refresh();
	}

	public void setLevel(int level) {
	fCurrentLevel= level;
	initialize(getSearchResult());
	getPage().getViewer().refresh();
	}

	}