/*******************************************************************************
* Copyright (c) 2000, 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.ui.views.markers.internal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
/**
* Represents a list of ConcreteMarkers.
*/
public class MarkerList {
private int[] markerCounts = null;
private ConcreteMarker[] markers;
/**
* Lazily created marker table - maps IMarkers onto ConcreteMarkers. Null if
* not created
*/
private Map markerTable;
/**
* Creates an initially empty marker list
*/
public MarkerList() {
this(new ConcreteMarker[0]);
}
public MarkerList(Collection markers) {
this((ConcreteMarker[]) markers.toArray(new ConcreteMarker[markers
.size()]));
}
/**
* Creates a list containing the given set of markers
*
* @param markers
*/
public MarkerList(ConcreteMarker[] markers) {
this.markers = markers;
}
/**
* Clears any cached collation keys. Use to free up some memory if the
* markers in this list won't be sorted for awhile.
*/
public void clearCache() {
for (int i = 0; i < markers.length; i++) {
ConcreteMarker marker = markers[i];
marker.clearCache();
}
markerTable = null;
}
/**
* Returns the marker table or lazily creates it if it doesn't exist yet
*
* @return a map of IMarker onto ConcreteMarker, containing all the
* ConcreteMarkers in the list
*/
private Map getMarkerMap() {
if (markerTable == null) {
markerTable = new HashMap();
for (int idx = 0; idx < markers.length; idx++) {
ConcreteMarker marker = markers[idx];
markerTable.put(marker.getMarker(), marker);
}
}
return markerTable;
}
/**
* Returns an existing marker from the list that is associated with the
* given IMarker
*
* @param toFind
* the IMarker to lookup in the list
* @return the ConcreteMarker that corresponds to the given IMarker
*/
public ConcreteMarker getMarker(IMarker toFind) {
return (ConcreteMarker) getMarkerMap().get(toFind);
}
/**
* Return the list of IMarkers contained in the receiver.
* @return IMarker[]
*/
public IMarker[] getIMarkers(){
IMarker[] iMarkers = new IMarker[markers.length];
for (int i = 0; i < markers.length; i++) {
iMarkers[i] = markers[i].getMarker();
}
return iMarkers;
}
public static ConcreteMarker createMarker(IMarker marker)
throws CoreException {
if (marker.isSubtypeOf(IMarker.TASK)) {
return new TaskMarker(marker);
} else if (marker.isSubtypeOf(IMarker.BOOKMARK)) {
return new BookmarkMarker(marker);
} else if (marker.isSubtypeOf(IMarker.PROBLEM)) {
return new ProblemMarker(marker);
} else {
return new ConcreteMarker(marker);
}
}
public void refresh() {
for (int markerIdx = 0; markerIdx < markers.length; markerIdx++) {
ConcreteMarker next = markers[markerIdx];
next.refresh();
}
}
public List asList() {
return Arrays.asList(markers);
}
public MarkerList findMarkers(Collection ofIMarker) {
List result = new ArrayList(ofIMarker.size());
Iterator iter = ofIMarker.iterator();
while (iter.hasNext()) {
IMarker next = (IMarker) iter.next();
ConcreteMarker marker = getMarker(next);
if (marker != null) {
result.add(marker);
}
}
return new MarkerList(result);
}
public static ConcreteMarker[] createMarkers(IMarker[] source)
throws CoreException {
ConcreteMarker[] result = new ConcreteMarker[source.length];
for (int idx = 0; idx < source.length; idx++) {
result[idx] = createMarker(source[idx]);
}
return result;
}
/**
* Computes the set of markers that match the given filter
*
* @param filters
* the filters to apply
* @param mon
* the monitor to update
* @param ignoreExceptions
* whether or not exception will be shown
* @return MarkerList
* @throws CoreException
*/
public static MarkerList compute(MarkerFilter[] filters,
IProgressMonitor mon, boolean ignoreExceptions)
throws CoreException {
Collection returnMarkers = new HashSet();// avoid duplicates
for (int i = 0; i < filters.length; i++) {
returnMarkers.addAll(filters[i].findMarkers(mon, ignoreExceptions));
}
return new MarkerList(returnMarkers);
}
/**
* Returns a new MarkerList containing all markers in the workspace of the
* specified types
*
* @param types
* @return IMarker[]
* @throws CoreException
*/
public static IMarker[] compute(String[] types) throws CoreException {
ArrayList result = new ArrayList();
IResource input = ResourcesPlugin.getWorkspace().getRoot();
for (int i = 0; i < types.length; i++) {
IMarker[] newMarkers = input.findMarkers(types[i], true,
IResource.DEPTH_INFINITE);
result.addAll(Arrays.asList(newMarkers));
}
return (IMarker[]) result.toArray(new IMarker[result.size()]);
}
/**
* Returns the markers in the list. Read-only.
*
* @return an array of markers in the list
*/
public ConcreteMarker[] toArray() {
return markers;
}
/**
* Returns the markers in this list. Read-only.
*
* @return the markers in the list
*/
// public Collection getMarkers() {
// return markers;
// }
/**
* Returns the number of items in the list
*
* @return the number of items
*/
public int getItemCount() {
return markers.length;
}
/**
* Returns the number of error markers in the list
*
* @return the number of errors
*/
public int getErrors() {
return getMarkerCounts()[IMarker.SEVERITY_ERROR];
}
/**
* Returns the number of info markers in the list
*
* @return the number of info markers
*/
public int getInfos() {
return getMarkerCounts()[IMarker.SEVERITY_INFO];
}
/**
* Returns the number of warning markers in the list
*
* @return the number of warning markers
*/
public int getWarnings() {
return getMarkerCounts()[IMarker.SEVERITY_WARNING];
}
/**
* Returns an array of marker counts where getMarkerCounts()[severity] is
* the number of markers in the list with the given severity.
*
* @return an array of marker counts
*/
private int[] getMarkerCounts() {
if (markerCounts == null) {
markerCounts = new int[] { 0, 0, 0 };
for (int idx = 0; idx < markers.length; idx++) {
ConcreteMarker marker = markers[idx];
if (marker instanceof ProblemMarker) {
int severity = ((ProblemMarker) markers[idx]).getSeverity();
if (severity >= 0 && severity <= 2) {
markerCounts[severity]++;
}
}
}
}
return markerCounts;
}
/**
* Get the array that is the internal representation of the marker list
* without making a copy.
*
* @return Object[]
*/
public Object[] getArray() {
return markers;
}
/**
* Get the size of the receiver.
*
* @return int
*/
public int getSize() {
return getArray().length;
}
/**
* Return the markers at index
*
* @param index
* @return ConcreteMarker
*/
public ConcreteMarker getMarker(int index) {
return markers[index];
}
/**
* Add the addedMarkers to the receiver.
* @param addedMarkers Collection of ConcreteMarker
* @param removedMarkers Collection of ConcreteMarker
*/
public void updateMarkers(Collection addedMarkers,Collection removedMarkers) {
List list = new ArrayList(asList());
list.addAll(addedMarkers);
list.removeAll(removedMarkers);
markers = new ConcreteMarker[list.size()];
list.toArray(markers);
}
/**
* Refresh all of the markers in the receiver.
*/
public void refreshAll() {
for (int i = 0; i < markers.length; i++) {
markers[i].refresh();
}
}
/**
* Clear all of the group settings in the receiver.
*/
public void clearGroups() {
for (int i = 0; i < markers.length; i++) {
markers[i].setGroup(null);
}
}
}