public String toString() {

        return description;

    }

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

 * Copyright (c) 2004 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials 

 * are made available under the terms of the Common Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/cpl-v10.html

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

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

package org.eclipse.ui.views.markers.internal;

import java.util.WeakHashMap;

import org.eclipse.core.resources.IMarker;

import org.eclipse.core.runtime.CoreException;

/**

 * Converts IMarker instances into ConcreteMarker instances

 * 

 * @since 3.1

 */

public class MarkerConverter {

    private WeakHashMap knownMarkers = new WeakHashMap();

    public MarkerConverter() {

    }

    public ConcreteMarker getMarker(IMarker toQuery) {

        ConcreteMarker marker = (ConcreteMarker)knownMarkers.get(toQuery);

        if (marker == null) {

            try {

                marker = MarkerList.createMarker(toQuery);

            } catch (CoreException e) {

            }

        }

        knownMarkers.put(toQuery, marker);

        return marker;

    }

}

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

 * Copyright (c) 2004 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials 

 * are made available under the terms of the Common Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/cpl-v10.html

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

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

package org.eclipse.ui.views.markers.internal;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.eclipse.core.resources.IMarker;

import org.eclipse.core.resources.IMarkerDelta;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IResourceChangeEvent;

import org.eclipse.core.resources.IResourceChangeListener;

import org.eclipse.core.resources.IResourceDelta;

import org.eclipse.core.resources.IWorkspaceRoot;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.IJobManager;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.jface.viewers.deferred.AbstractConcurrentContentProvider;

import org.eclipse.jface.viewers.deferred.IConcurrentContentProviderListener;

/**

 * @since 3.1

 */

public class MarkerProvider extends AbstractConcurrentContentProvider {

    private static final String WAITING_FOR_WORKSPACE_CHANGES_TO_FINISH = Messages

            .getString("MarkerView.waiting_on_changes"); //$NON-NLS-1$

    private static final String SEARCHING_FOR_MARKERS = Messages

            .getString("MarkerView.searching_for_markers"); //$NON-NLS-1$

    private static final String REFRESHING_MARKER_COUNTS = Messages

            .getString("MarkerView.refreshing_counts"); //$NON-NLS-1$

    private IWorkspaceRoot getWorkspaceRoot() {

        return ResourcesPlugin.getWorkspace().getRoot();

    }

    private Job searchJob = new Job(SEARCHING_FOR_MARKERS) {

	    /* (non-Javadoc)

	     * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)

	     */

	    protected IStatus run(IProgressMonitor monitor) {

	        doRefresh(monitor);

	        return Status.OK_STATUS;

	    }  

    };

    private MarkerConverter converter = new MarkerConverter();

    private int totalMarkers = 0;

    private boolean markerCountDirty = false;

    private MarkerList currentMarkers = new MarkerList();

    private ArrayList awaitingRefresh = new ArrayList();

    IResourceChangeListener resourceListener = new IResourceChangeListener() {

        public void resourceChanged(IResourceChangeEvent event) {

            MarkerProvider.this.resourceChanged(event);

        }

    };

    public MarkerProvider() {

        ResourcesPlugin.getWorkspace().addResourceChangeListener(resourceListener);

    }

    public void resourceChanged(IResourceChangeEvent event) {

        String[] markerTypes = getMarkerTypes();

        boolean refreshNeeded = false;

        for (int idx = 0; idx < markerTypes.length; idx++) {

            IMarkerDelta[] markerDeltas = event.findMarkerDeltas(

                    markerTypes[idx], true);

            List changes = new ArrayList(markerDeltas.length / 3);

            List additions = new ArrayList(markerDeltas.length / 3);

            List removals = new ArrayList(markerDeltas.length / 3);

            examineDelta(markerDeltas, changes, additions, removals);

            fireRemove(removals.toArray());

            fireAdd(additions.toArray());

            fireUpdate(changes.toArray());            

        }

    }

    private void examineDelta(IMarkerDelta[] deltas, List changes, List additions, List removals) {

        for (int idx = 0; idx < deltas.length; idx++) {

            IMarkerDelta delta = deltas[idx];

            int kind = delta.getKind();

            if (kind == IResourceDelta.CHANGED) {

                changes.add(converter.getMarker(deltas[idx].getMarker()));

            } else if (kind == IResourceDelta.ADDED) {

                additions.add(converter.getMarker(deltas[idx].getMarker()));

            } else if (kind == IResourceDelta.REMOVED) {

                removals.add(converter.getMarker(deltas[idx].getMarker()));

            }

        }

    }

    public void dispose() {

        ResourcesPlugin.getWorkspace().removeResourceChangeListener(resourceListener);

    }

    public int getTotalMarkers() {

        return totalMarkers;

    }

    private String[] getMarkerTypes() {

        return new String[] {IMarker.MARKER};

    }

    /* (non-Javadoc)

     * @see org.eclipse.jface.viewers.deferred.IConcurrentContentProvider#getElements(org.eclipse.core.runtime.IProgressMonitor)

     */

    public void doRefresh(IProgressMonitor monitor) {

        IJobManager jobMan = Platform.getJobManager();

        IWorkspaceRoot root = getWorkspaceRoot();

        ArrayList result = new ArrayList();

        try {

            monitor.subTask(WAITING_FOR_WORKSPACE_CHANGES_TO_FINISH);

            jobMan.beginRule(root, monitor);

            if (monitor.isCanceled()) {

                throw new InterruptedException();

            }

            monitor.subTask(SEARCHING_FOR_MARKERS);

            IMarker[] markers = root.findMarkers(IMarker.MARKER,

                    true, IResource.DEPTH_INFINITE);

            for (int i = 0; i < markers.length; i++) {

                IMarker marker = markers[i];

                ConcreteMarker next = converter.getMarker(marker);

                next.refresh();

                result.add(next);

            }

        } catch (CoreException e) {

            // TODO: SHOULD LOG THIS!!!!!!!!!!!!

        } catch (InterruptedException e) {

        } finally {

            jobMan.endRule(root);

        }

        synchronized(awaitingRefresh) {

            for (Iterator iter = awaitingRefresh.iterator(); iter.hasNext();) {

                IConcurrentContentProviderListener listener = (IConcurrentContentProviderListener) iter.next();

                listener.setContents(result.toArray());

            }

            awaitingRefresh.clear();

        }

    }

    /* (non-Javadoc)

     * @see org.eclipse.jface.viewers.deferred.IConcurrentContentProvider#requestUpdate(org.eclipse.jface.viewers.deferred.IConcurrentContentProviderListener)

     */

    public void requestUpdate(IConcurrentContentProviderListener listener) {

        synchronized(awaitingRefresh) {

            awaitingRefresh.add(listener);

            searchJob.schedule();

        }

    }

}