/******************************************************************************* | |
* Copyright (c) 2000, 2010 IBM Corporation, See4sys 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 | |
* See4sys - added support for problem markers on model objects (rather than | |
* only on workspace resources). Unfortunately, there was no other | |
* choice than copying the whole code from | |
* org.eclipse.ui.views.markers.internal for that purpose because | |
* many of the relevant classes, methods, and fields are private or | |
* package private. | |
*******************************************************************************/ | |
package org.eclipse.sphinx.emf.validation.ui.views; | |
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 (ConcreteMarker marker : markers) { | |
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 (ConcreteMarker marker : markers) { | |
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.PROBLEM)) { | |
return new ProblemMarker(marker); | |
} else { | |
return new ConcreteMarker(marker); | |
} | |
} | |
public void refresh() { | |
for (ConcreteMarker next : markers) { | |
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 (MarkerFilter element : filters) { | |
returnMarkers.addAll(element.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 (String element : types) { | |
IMarker[] newMarkers = input.findMarkers(element, 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 (ConcreteMarker marker : markers) { | |
if (marker instanceof ProblemMarker) { | |
int severity = ((ProblemMarker) marker).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 (ConcreteMarker element : markers) { | |
element.refresh(); | |
} | |
} | |
/** | |
* Clear all of the group settings in the receiver. | |
*/ | |
public void clearGroups() { | |
for (ConcreteMarker element : markers) { | |
element.setGroup(null); | |
} | |
} | |
} |