plugins/org.eclipse.epf.library.persistence/src/org/eclipse/epf/persistence/util/UnresolvedProxyMarkerManager.java - gerrit/epf/org.eclipse.epf.archive - Git at Google

 //------------------------------------------------------------------------------
 // Copyright (c) 2005, 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 implementation
 //------------------------------------------------------------------------------
 package org.eclipse.epf.persistence.util;

 import java.util.ArrayList;
 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 java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import org.eclipse.core.filebuffers.FileBuffers;
 import org.eclipse.core.filebuffers.ITextFileBuffer;
 import org.eclipse.core.filebuffers.ITextFileBufferManager;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspace;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.resources.WorkspaceJob;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.emf.common.CommonPlugin;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.common.util.UniqueEList;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.epf.persistence.FileManager;
 import org.eclipse.epf.persistence.MultiFileResourceSetImpl;
 import org.eclipse.epf.persistence.MultiFileSaveUtil;
 import org.eclipse.epf.persistence.PersistencePlugin;
 import org.eclipse.epf.uma.ecore.IProxyResolutionListener;
 import org.eclipse.epf.uma.ecore.ResolveException;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.osgi.util.NLS;


 /**
  * Background job that manage markers for unresolved proxies
  *
  * @author Phong Nguyen Le
  * @since 1.0
  */
 public class UnresolvedProxyMarkerManager extends WorkspaceJob implements IProxyResolutionListener {

 	private static final long DELAY = 0;
 	public static final String PROXY_URI = "proxyURI"; //$NON-NLS-1$
 	public static final String OWNER_GUID = "ownerGUID"; //$NON-NLS-1$

 	private static class ValidObject {
 		boolean valid;
 		Object object;

 		/**
 		 * @param valid
 		 * @param object
 		 */
 		public ValidObject(Object object) {
 			super();
 			this.object = object;
 			valid = true;
 		}

 	}

 	private Map uriToExceptionsMap;
 	private List exceptions;
 	private Map resourceGUIToMarkersMap;
 	private Map elementGUIToMarkersMap;
 	private ResourceSet resourceSet;
 	private boolean enabled;
 	private List resourcesToValidateMarkers;

 	public UnresolvedProxyMarkerManager(ResourceSet resourceSet) {
 		super("EPF Unresolved Proxy Logger"); //$NON-NLS-1$
 		this.resourceSet = resourceSet;
 //		unresolvedResourceGUIDToMarkersMap = new HashMap();
 		uriToExceptionsMap = new HashMap();
 		exceptions = new ArrayList();
 		resourceGUIToMarkersMap = new HashMap();
 		elementGUIToMarkersMap = new HashMap();
 		resourcesToValidateMarkers = new UniqueEList();
 	}

 	public IMarker findMarker(IFile file, String proxyURI, int start, int end) throws CoreException {
 		IMarker[] markers = file.findMarkers(IMarker.PROBLEM, false, IResource.DEPTH_ZERO);
 		for (int i = 0; i < markers.length; i++) {
 			IMarker marker = markers[i];
 			if(proxyURI.equals(marker.getAttribute(PROXY_URI))
 					&& marker.getAttribute(IMarker.CHAR_START, -1) == start
 					&& marker.getAttribute(IMarker.CHAR_END, -1) == end)
 			{
 				return marker;
 			}
 		}
 		return null;
 	}

 	private boolean addException(ResolveException re) {
 		synchronized(exceptions) {
 			URI uri = ((InternalEObject)re.getProxy()).eProxyURI();
 			Set exceptions = (Set) uriToExceptionsMap.get(uri);
 			if(exceptions == null) {
 				exceptions = new HashSet();
 				uriToExceptionsMap.put(uri, exceptions);
 			}
 			if(exceptions.add(re)) {
 				this.exceptions.add(re);
 				return true;
 			}
 			return false;
 		}
 	}

 	/**
 	 * Document based character sequence.
 	 */
 	private static class DocumentCharSequence implements CharSequence {

 		/** Document */
 		private IDocument fDocument;

 		/**
 		 * Initialize with the sequence of characters in the given
 		 * document.
 		 *
 		 * @param document the document
 		 */
 		public DocumentCharSequence(IDocument document) {
 			fDocument= document;
 		}

 		/*
 		 * @see java.lang.CharSequence#length()
 		 */
 		public int length() {
 			return fDocument.getLength();
 		}

 		/*
 		 * @see java.lang.CharSequence#charAt(int)
 		 */
 		public char charAt(int index) {
 			try {
 				return fDocument.getChar(index);
 			} catch (BadLocationException x) {
 				throw new IndexOutOfBoundsException(x.getLocalizedMessage());
 			}
 		}

 		/*
 		 * @see java.lang.CharSequence#subSequence(int, int)
 		 */
 		public CharSequence subSequence(int start, int end) {
 			try {
 				return fDocument.get(start, end - start);
 			} catch (BadLocationException x) {
 				throw new IndexOutOfBoundsException(x.getLocalizedMessage());
 			}
 		}
 	}

 	private void addMarker(Resource resource, URI proxyURI, String errMsg, String ownerGUID, IProgressMonitor monitor) {
 		URI containerURI = resource.getURI();
 		IWorkspace workspace = ResourcesPlugin.getWorkspace();
 		IPath path = new Path(containerURI.toFileString());
 		IFile file = workspace.getRoot().getFileForLocation(path);
 		if (file != null) {
 			String location = containerURI != null ? containerURI
 					.toFileString() : ""; //$NON-NLS-1$

 			try {
 				file.refreshLocal(IResource.DEPTH_ZERO, null);

 				// locate the text of unresolved URI in file
 				//
 				ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
 				try {
 					manager.connect(path, monitor);
 					ITextFileBuffer fileBuffer= manager.getTextFileBuffer(path);
 					fileBuffer.requestSynchronizationContext();
 					fileBuffer.getDocument();
 					IDocument doc = fileBuffer.getDocument();
 					if(doc != null) {
 						String proxyURIStr = proxyURI.toString();
 						Pattern pattern = PatternConstructor.createPattern(proxyURIStr, true, false);
 						Matcher matcher = pattern.matcher(new DocumentCharSequence(doc));
 						while(matcher.find()) {
 							int start = matcher.start();
 							int end = matcher.end();
 							if(start != end) {
 								// make sure that resolver is still in the open library by checking whether its resource
 								// still belongs to a resource set
 								//
 								if(resource != null && resource.getResourceSet() != null) {
 									// create problem marker for file
 									IMarker marker = findMarker(file, proxyURIStr, start, end);
 									if(marker == null) {
 										marker = file.createMarker(IMarker.PROBLEM);
 										marker.setAttribute(IMarker.SEVERITY,
 												IMarker.SEVERITY_ERROR);
 										marker.setAttribute(IMarker.MESSAGE, errMsg);
 										marker.setAttribute(IMarker.LOCATION, location);
 										marker.setAttribute(IMarker.TRANSIENT, true);
 										marker.setAttribute(IMarker.CHAR_START, start);
 										marker.setAttribute(IMarker.CHAR_END, end);
 										marker.setAttribute(PROXY_URI, proxyURIStr);
 										marker.setAttribute(OWNER_GUID, ownerGUID);

 										// cache marker to it can be found easily and deleted
 										//
 										cacheMarker(marker, proxyURI);
 									}
 									else {
 										// update owner GUID
 										//
 										marker.setAttribute(OWNER_GUID, ownerGUID);
 									}
 								}
 							}
 						}
 					}
 					fileBuffer.releaseSynchronizationContext();
 				}
 				finally {
 					manager.disconnect(path, monitor);
 				}
 			} catch (CoreException ex) {
 				CommonPlugin.INSTANCE.log(ex);
 				if (MultiFileSaveUtil.DEBUG) {
 					ex.printStackTrace();
 				}
 			}
 		}
 	}

 	private void addMarker(ResolveException re, IProgressMonitor monitor) {
 		InternalEObject proxy = (InternalEObject) re.getProxy();
 		URI containerURI = null;
 		Resource resource = null;
 		if(re.getResolver() != null) {
 			resource = re.getResolver().eResource();

 			// make sure that resolver is still in the open library by checking whether its resource
 			// still belongs to a resource set
 			//
 //			System.out.println("UnresolvedProxyMarkerManager.addMarker(): resourceSet=" + resource.getResourceSet().hashCode());
 			if(resource != null && resource.getResourceSet() != null) {
 				containerURI = resource.getURI();
 			}
 		}
 		if (containerURI != null) {
 			IWorkspace workspace = ResourcesPlugin.getWorkspace();
 			IPath path = new Path(containerURI.toFileString());
 			IFile file = workspace.getRoot().getFileForLocation(path);
 			if (file != null) {
 				String errMsg;
 				if (re.exception() != null && re.exception().getLocalizedMessage() != null &&
 						re.exception().getLocalizedMessage().trim().length() > 0) {
 					errMsg = re.exception().getLocalizedMessage();
 				}
 				else {
 					errMsg = re.getMessage() == null ? NLS.bind(PersistenceResources.UnresolvedProxyMarkerManager_couldNotResolveProxy, proxy.eProxyURI()) : re
 								.getMessage();
 				}
 				addMarker(resource, proxy.eProxyURI(), errMsg, MultiFileSaveUtil.getGuid(re.getResolver()), monitor);
 			}
 		}
 	}

 	/**
 	 * @param marker
 	 * @param uri proxy uri
 	 */
 	private void cacheMarker(IMarker marker, URI uri) {
 		synchronized(elementGUIToMarkersMap) {
 			String resourceGUID = uri.authority();
 			if(resourceGUID != null) {
 				ValidObject vo = (ValidObject) resourceGUIToMarkersMap.get(resourceGUID);
 				if(vo == null) {
 					vo = new ValidObject(new HashSet());
 					resourceGUIToMarkersMap.put(resourceGUID, vo);
 				}
 				Collection markers = (Collection) vo.object;
 				markers.add(marker);
 			}
 			String elementGUID = uri.fragment();
 			Collection markers = (Collection) elementGUIToMarkersMap.get(elementGUID);
 			if(markers == null) {
 				markers = new HashSet();
 				elementGUIToMarkersMap.put(elementGUID, markers);
 			}
 			markers.add(new ValidObject(marker));
 		}
 	}

 	public void clearAll() {
 		boolean oldEnabled = enabled;
 		try {
 			enabled = false;
 			cancel();

 			synchronized (exceptions) {
 				uriToExceptionsMap.clear();
 				exceptions.clear();
 			}
 			synchronized(elementGUIToMarkersMap) {
 				if(!elementGUIToMarkersMap.isEmpty()) {
 					for (Iterator iter = elementGUIToMarkersMap.values().iterator(); iter.hasNext();) {
 						Collection markers = (Collection) iter.next();
 						for (Iterator iter1 = markers.iterator(); iter1.hasNext();) {
 							ValidObject vo = (ValidObject) iter1.next();
 							IMarker marker = (IMarker) vo.object;
 							try {
 								if(marker.exists()) {
 									marker.delete();
 								}
 							}
 							catch(Exception e) {
 								CommonPlugin.INSTANCE.log(e);
 							}
 						}
 						markers.clear();
 					}
 					elementGUIToMarkersMap.clear();
 					resourceGUIToMarkersMap.clear();
 				}
 			}
 			synchronized(resourcesToValidateMarkers) {
 				resourcesToValidateMarkers.clear();
 			}
 		}
 		finally {
 			enabled = oldEnabled;
 //			System.out.println("UnresolvedProxyMarkerManager.clearAll(): end");
 		}
 	}

 	public boolean hasUnresolvedProxy() {
 		return !elementGUIToMarkersMap.isEmpty();
 	}

 	private ResolveException nextException() {
 		synchronized(exceptions) {
 			// synchronized: in order to atomically obtain and clear requests
 			if(exceptions.isEmpty()) {
 				return null;
 			}
 			else {
 				ResolveException e = (ResolveException) this.exceptions.remove(0);
 				URI uri = ((InternalEObject)e.getProxy()).eProxyURI();
 				Collection exceptions = (Collection) uriToExceptionsMap.get(uri);
 				if(exceptions != null) {
 					exceptions.remove(e);
 					if(exceptions.isEmpty()) {
 						uriToExceptionsMap.remove(uri);
 					}
 				}
 				return e;
 			}
 		}
 	}

 	private Resource nextResourceToValidateMarkers() {
 		synchronized(resourcesToValidateMarkers) {
 			if(resourcesToValidateMarkers.isEmpty()) {
 				return null;
 			}
 			else {
 				return (Resource) resourcesToValidateMarkers.remove(0);
 			}
 		}
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.core.resources.WorkspaceJob#runInWorkspace(org.eclipse.core.runtime.IProgressMonitor)
 	 */
 	public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
 //		System.out.println("UnresolvedProxyMarkerManager.runInWorkspace(): begin");
 		try {
 		if(!enabled) return Status.OK_STATUS;

 		try {
 			// add markers
 			//
 			ResolveException re;
 			while((re = nextException()) != null) {
 				try {
 					addMarker(re, monitor);
 				}
 				catch(Exception e) {
 					CommonPlugin.INSTANCE.log(e);
 				}
 			}

 			// remove invalid markers
 			//
 			removeMarkers(monitor);

 			// validate resource markers
 			//
 			Resource resource;
 			while((resource = nextResourceToValidateMarkers()) != null) {
 				doValidateMarkers(resource);
 			}
 		}
 		catch(Exception e) {
 			CommonPlugin.INSTANCE.log(e);
 		}

 		return Status.OK_STATUS;
 		}
 		finally {
 //			System.out.println("UnresolvedProxyMarkerManager.runInWorkspace(): end");
 		}
 	}

 	private boolean removeFromResourceGUIDToMarkersMap(String proxyURI, IMarker marker) {
 		URI uri = URI.createURI(proxyURI);
 		String resourceGUID = uri.authority();
 		if(resourceGUID != null) {
 			ValidObject vo = (ValidObject) resourceGUIToMarkersMap.get(resourceGUID);
 			if(vo != null) {
 				Collection markers = ((Collection)vo.object);
 				boolean ret = markers.remove(marker);
 				if(markers.isEmpty()) {
 					resourceGUIToMarkersMap.remove(resourceGUID);
 				}
 				return ret;
 			}
 		}
 		return false;
 	}

 	private void removeFromElementGUIDToMarkersMap(String proxyURI, IMarker marker) {
 		URI uri = URI.createURI(proxyURI);
 		String elementGUID = uri.fragment();
 		if(elementGUID != null) {
 			Collection validObjects = (Collection) elementGUIToMarkersMap.get(elementGUID);
 			if(validObjects != null) {
 				for (Iterator iterator1 = validObjects.iterator(); iterator1
 				.hasNext();) {
 					ValidObject vo1 = (ValidObject) iterator1.next();
 					if(vo1.object == marker) {
 						iterator1.remove();
 					}
 				}
 				if(validObjects.isEmpty()) {
 					elementGUIToMarkersMap.remove(elementGUID);
 				}
 			}
 		}
 	}

 	private void removeMarkers(IProgressMonitor monitor) {
 		synchronized(elementGUIToMarkersMap) {
 		for (Iterator iter = elementGUIToMarkersMap.values().iterator(); iter.hasNext();) {
 			Collection markers = (Collection) iter.next();
 			for (Iterator iterator = markers.iterator(); iterator.hasNext();) {
 				ValidObject vo = (ValidObject) iterator.next();
 				if(!vo.valid) {
 					try {
 						IMarker marker = (IMarker) vo.object;
 						if(marker.exists()) {
 							String proxyURI = (String) marker.getAttribute(PROXY_URI);

 							marker.delete();

 							// remove this marker from resourceGUIToMarkersMap
 							//
 							removeFromResourceGUIDToMarkersMap(proxyURI, marker);
 						}
 						iterator.remove();

 					} catch (Exception e) {
 						CommonPlugin.INSTANCE.log(e);
 					}
 				}
 			}
 		}
 		for (Iterator iter = resourceGUIToMarkersMap.values().iterator(); iter.hasNext();) {
 			ValidObject vo = (ValidObject) iter.next();
 			if(!vo.valid) {
 				vo.valid = true;
 				Collection markers = (Collection) vo.object;
 				for (Iterator iterator = markers.iterator(); iterator.hasNext();) {
 					IMarker marker;
 					try {
 						marker = (IMarker) iterator.next();
 						if(marker.exists()) {
 							String proxyURIStr = (String) marker.getAttribute(PROXY_URI);
 							URI proxyURI = URI.createURI(proxyURIStr);

 							// proxy is in the same resource that is just loaded
 							// try to get the object with this proxy URI without loading new resource
 							//
 //							EObject o = resourceSet.getEObject(proxyURI, false);
 							String elementGUID = proxyURI.fragment();
 							EObject o = (EObject) ((MultiFileResourceSetImpl)resourceSet).getGuidToMethodElementMap().get(elementGUID);
 							if(o != null && !o.eIsProxy()) {
 								marker.delete();
 								iterator.remove();

 								// remove this marker from elementGUIToMarkersMap
 								//
 								removeFromElementGUIDToMarkersMap(proxyURIStr, marker);
 							}
 						}
 						else {
 							iterator.remove();
 						}
 					}
 					catch(Exception e) {
 						CommonPlugin.INSTANCE.log(e);
 					}
 				}
 				if(markers.isEmpty()) {
 					iter.remove();
 				}
 			}
 		}
 		}
 	}

 	public void setEnabled(boolean enabled) {
 		this.enabled = enabled;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.epf.uma.ecore.IProxyResolutionListener#notifyException(java.lang.Exception)
 	 */
 	public void notifyException(Exception e) {
 		if(!enabled) return;

 		if(e instanceof ResolveException) {
 			ResolveException re = (ResolveException) e;

 //			URI uri = ((InternalEObject)re.getProxy()).eProxyURI();
 //			if("_2J4YoPTDEdmkpYARNN468A".equals(uri.fragment())) {
 //				System.out.println();
 //			}

 			if(addException(re)) {
 				schedule(DELAY);
 			}
 		}
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.epf.uma.ecore.IProxyResolutionListener#proxyResolved(java.lang.Object, java.lang.Object)
 	 */
 	public void proxyResolved(Object proxy, Object resolved) {
 		if(!enabled) return;

 		if(proxy instanceof InternalEObject) {
 			URI uri = ((InternalEObject)proxy).eProxyURI();

 //			if("_2J4YoPTDEdmkpYARNN468A".equals(uri.fragment())) {
 //				System.out.println();
 //			}

 			// remove all exceptions for this URI
 			//
 			removeExceptions(uri);

 			// invalidate all markers for this URI
 			//
 			if(invalidateMarkers(uri)) {
 				schedule(DELAY);
 			}
 		}
 	}

 	/**
 	 * @param uri
 	 */
 	private boolean invalidateMarkers(URI uri) {
 		synchronized(elementGUIToMarkersMap) {
 			boolean ret = false;
 			String resourceGUID = uri.authority();
 			if(resourceGUID != null) {
 				ValidObject vo = (ValidObject) resourceGUIToMarkersMap.get(resourceGUID);
 				if(vo != null) {
 					vo.valid = false;
 					ret = true;
 				}
 			}
 			String elementGUID = uri.fragment();
 			if(elementGUID != null) {
 				Collection markers = (Collection) elementGUIToMarkersMap.get(elementGUID);
 				if(markers != null && !markers.isEmpty()) {
 					ret = true;
 					for (Iterator iter = markers.iterator(); iter.hasNext();) {
 						ValidObject vo = (ValidObject) iter.next();
 						vo.valid = false;
 					}
 				}
 			}
 			return ret;
 		}
 	}

 	/**
 	 * @param uri
 	 */
 	private void removeExceptions(URI uri) {
 		synchronized (exceptions) {
 			Collection exceptions = (Collection) uriToExceptionsMap.get(uri);
 			if(exceptions == null || exceptions.isEmpty()) return;
 			this.exceptions.removeAll(exceptions);
 			uriToExceptionsMap.remove(uri);
 		}
 	}

 	/**
 	 * Clears markers for unresolved proxies of the given resource
 	 *
 	 * @param resource
 	 */
 	public void clearMarkers(Resource resource) {
 		try {
 			IResource file = FileManager.getResourceForLocation(resource.getURI().toFileString());
 			if(file instanceof IFile) {
 				IMarker[] markers = file.findMarkers(IMarker.PROBLEM, false, IResource.DEPTH_ZERO);
 				for (int i = 0; i < markers.length; i++) {
 					IMarker marker = markers[i];
 					removeMarker(marker);
 				}
 			}
 		}
 		catch(Exception e) {
 			PersistencePlugin.getDefault().getLogger().logError(e);
 		}
 	}

 	public void removeMarker(IMarker marker) {
 		String proxyURI = null;
 		try {
 			if(marker.exists()) {
 				proxyURI = (String) marker.getAttribute(PROXY_URI);
 				marker.delete();
 			}
 		} catch (Exception e) {
 			PersistencePlugin.getDefault().getLogger().logError(e);
 		}
 		if(proxyURI != null) {
 			synchronized(elementGUIToMarkersMap) {
 				removeFromElementGUIDToMarkersMap(proxyURI, marker);
 				removeFromResourceGUIDToMarkersMap(proxyURI, marker);
 			}
 		}
 	}

 	private static class MarkerInfo {
 		String proxyURI;
 		String ownerGUID;
 		String message;

 		/* (non-Javadoc)
 		 * @see java.lang.Object#equals(java.lang.Object)
 		 */
 		public boolean equals(Object obj) {
 			if(obj instanceof MarkerInfo) {
 				MarkerInfo info = (MarkerInfo) obj;
 				if(proxyURI != null && ownerGUID != null && proxyURI.equals(info.proxyURI) && ownerGUID.equals(info.ownerGUID)) {
 					return true;
 				}
 			}
 			return super.equals(obj);
 		}
 	}

 	/**
 	 * Validates markers for unresolved proxies of the given resource
 	 *
 	 * @param resource
 	 */
 	public void validateMarkers(Resource resource) {
 		boolean newlyAdded = false;
 		synchronized(resourcesToValidateMarkers) {
 			newlyAdded = resourcesToValidateMarkers.add(resource);
 		}
 		if(newlyAdded) {
 			schedule(DELAY);
 		}
 	}

 	private void doValidateMarkers(Resource resource) {
 		try {
 			IResource file = FileManager.getResourceForLocation(resource.getURI().toFileString());
 			if(file instanceof IFile) {
 				IMarker[] markers = file.findMarkers(IMarker.PROBLEM, false, IResource.DEPTH_ZERO);
 				HashSet markerInfos = new HashSet();
 				for (int i = 0; i < markers.length; i++) {
 					IMarker marker = markers[i];
 					String proxyURI = (String) marker.getAttribute(PROXY_URI);
 					if(proxyURI != null) {
 						URI uri = URI.createURI(proxyURI);
 						// try to get the object with this proxy URI without loading new resource
 						//
 						String elementGUID = uri.fragment();
 						EObject o = (EObject) ((MultiFileResourceSetImpl)resourceSet).getGuidToMethodElementMap().get(elementGUID);
 						if(o == null || o.eIsProxy()) {
 							MarkerInfo info = new MarkerInfo();
 							info.message = (String) marker.getAttribute(IMarker.MESSAGE);
 							info.ownerGUID = (String) marker.getAttribute(OWNER_GUID);
 							info.proxyURI = proxyURI;
 							markerInfos.add(info);
 						}

 						if(marker.exists()) {
 							try {
 								marker.delete();
 							}
 							catch(Exception e) {
 								PersistencePlugin.getDefault().getLogger().logError(e);
 							}
 						}
 						synchronized(elementGUIToMarkersMap) {
 							removeFromElementGUIDToMarkersMap(proxyURI, marker);
 							removeFromResourceGUIDToMarkersMap(proxyURI, marker);
 						}

 					}
 				}
 				if(!markerInfos.isEmpty()) {
 					for (Iterator iter = markerInfos.iterator(); iter.hasNext();) {
 						MarkerInfo info = (MarkerInfo) iter.next();
 						addMarker(resource, URI.createURI(info.proxyURI), info.message, info.ownerGUID, new NullProgressMonitor());
 					}
 				}
 			}
 		}
 		catch(Exception e) {
 			PersistencePlugin.getDefault().getLogger().logError(e);
 		}
 	}

 }
	//------------------------------------------------------------------------------
	// Copyright (c) 2005, 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 implementation
	//------------------------------------------------------------------------------
	package org.eclipse.epf.persistence.util;

	import java.util.ArrayList;
	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 java.util.Set;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import org.eclipse.core.filebuffers.FileBuffers;
	import org.eclipse.core.filebuffers.ITextFileBuffer;
	import org.eclipse.core.filebuffers.ITextFileBufferManager;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IMarker;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IWorkspace;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.resources.WorkspaceJob;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.emf.common.CommonPlugin;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.common.util.UniqueEList;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.InternalEObject;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.epf.persistence.FileManager;
	import org.eclipse.epf.persistence.MultiFileResourceSetImpl;
	import org.eclipse.epf.persistence.MultiFileSaveUtil;
	import org.eclipse.epf.persistence.PersistencePlugin;
	import org.eclipse.epf.uma.ecore.IProxyResolutionListener;
	import org.eclipse.epf.uma.ecore.ResolveException;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.osgi.util.NLS;


	/**
	* Background job that manage markers for unresolved proxies
	*
	* @author Phong Nguyen Le
	* @since 1.0
	*/
	public class UnresolvedProxyMarkerManager extends WorkspaceJob implements IProxyResolutionListener {

	private static final long DELAY = 0;
	public static final String PROXY_URI = "proxyURI"; //$NON-NLS-1$
	public static final String OWNER_GUID = "ownerGUID"; //$NON-NLS-1$

	private static class ValidObject {
	boolean valid;
	Object object;

	/**
	* @param valid
	* @param object
	*/
	public ValidObject(Object object) {
	super();
	this.object = object;
	valid = true;
	}

	}

	private Map uriToExceptionsMap;
	private List exceptions;
	private Map resourceGUIToMarkersMap;
	private Map elementGUIToMarkersMap;
	private ResourceSet resourceSet;
	private boolean enabled;
	private List resourcesToValidateMarkers;

	public UnresolvedProxyMarkerManager(ResourceSet resourceSet) {
	super("EPF Unresolved Proxy Logger"); //$NON-NLS-1$
	this.resourceSet = resourceSet;
	// unresolvedResourceGUIDToMarkersMap = new HashMap();
	uriToExceptionsMap = new HashMap();
	exceptions = new ArrayList();
	resourceGUIToMarkersMap = new HashMap();
	elementGUIToMarkersMap = new HashMap();
	resourcesToValidateMarkers = new UniqueEList();
	}

	public IMarker findMarker(IFile file, String proxyURI, int start, int end) throws CoreException {
	IMarker[] markers = file.findMarkers(IMarker.PROBLEM, false, IResource.DEPTH_ZERO);
	for (int i = 0; i < markers.length; i++) {
	IMarker marker = markers[i];
	if(proxyURI.equals(marker.getAttribute(PROXY_URI))
	&& marker.getAttribute(IMarker.CHAR_START, -1) == start
	&& marker.getAttribute(IMarker.CHAR_END, -1) == end)
	{
	return marker;
	}
	}
	return null;
	}

	private boolean addException(ResolveException re) {
	synchronized(exceptions) {
	URI uri = ((InternalEObject)re.getProxy()).eProxyURI();
	Set exceptions = (Set) uriToExceptionsMap.get(uri);
	if(exceptions == null) {
	exceptions = new HashSet();
	uriToExceptionsMap.put(uri, exceptions);
	}
	if(exceptions.add(re)) {
	this.exceptions.add(re);
	return true;
	}
	return false;
	}
	}

	/**
	* Document based character sequence.
	*/
	private static class DocumentCharSequence implements CharSequence {

	/** Document */
	private IDocument fDocument;

	/**
	* Initialize with the sequence of characters in the given
	* document.
	*
	* @param document the document
	*/
	public DocumentCharSequence(IDocument document) {
	fDocument= document;
	}

	/*
	* @see java.lang.CharSequence#length()
	*/
	public int length() {
	return fDocument.getLength();
	}

	/*
	* @see java.lang.CharSequence#charAt(int)
	*/
	public char charAt(int index) {
	try {
	return fDocument.getChar(index);
	} catch (BadLocationException x) {
	throw new IndexOutOfBoundsException(x.getLocalizedMessage());
	}
	}

	/*
	* @see java.lang.CharSequence#subSequence(int, int)
	*/
	public CharSequence subSequence(int start, int end) {
	try {
	return fDocument.get(start, end - start);
	} catch (BadLocationException x) {
	throw new IndexOutOfBoundsException(x.getLocalizedMessage());
	}
	}
	}

	private void addMarker(Resource resource, URI proxyURI, String errMsg, String ownerGUID, IProgressMonitor monitor) {
	URI containerURI = resource.getURI();
	IWorkspace workspace = ResourcesPlugin.getWorkspace();
	IPath path = new Path(containerURI.toFileString());
	IFile file = workspace.getRoot().getFileForLocation(path);
	if (file != null) {
	String location = containerURI != null ? containerURI
	.toFileString() : ""; //$NON-NLS-1$

	try {
	file.refreshLocal(IResource.DEPTH_ZERO, null);

	// locate the text of unresolved URI in file
	//
	ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
	try {
	manager.connect(path, monitor);
	ITextFileBuffer fileBuffer= manager.getTextFileBuffer(path);
	fileBuffer.requestSynchronizationContext();
	fileBuffer.getDocument();
	IDocument doc = fileBuffer.getDocument();
	if(doc != null) {
	String proxyURIStr = proxyURI.toString();
	Pattern pattern = PatternConstructor.createPattern(proxyURIStr, true, false);
	Matcher matcher = pattern.matcher(new DocumentCharSequence(doc));
	while(matcher.find()) {
	int start = matcher.start();
	int end = matcher.end();
	if(start != end) {
	// make sure that resolver is still in the open library by checking whether its resource
	// still belongs to a resource set
	//
	if(resource != null && resource.getResourceSet() != null) {
	// create problem marker for file
	IMarker marker = findMarker(file, proxyURIStr, start, end);
	if(marker == null) {
	marker = file.createMarker(IMarker.PROBLEM);
	marker.setAttribute(IMarker.SEVERITY,
	IMarker.SEVERITY_ERROR);
	marker.setAttribute(IMarker.MESSAGE, errMsg);
	marker.setAttribute(IMarker.LOCATION, location);
	marker.setAttribute(IMarker.TRANSIENT, true);
	marker.setAttribute(IMarker.CHAR_START, start);
	marker.setAttribute(IMarker.CHAR_END, end);
	marker.setAttribute(PROXY_URI, proxyURIStr);
	marker.setAttribute(OWNER_GUID, ownerGUID);

	// cache marker to it can be found easily and deleted
	//
	cacheMarker(marker, proxyURI);
	}
	else {
	// update owner GUID
	//
	marker.setAttribute(OWNER_GUID, ownerGUID);
	}
	}
	}
	}
	}
	fileBuffer.releaseSynchronizationContext();
	}
	finally {
	manager.disconnect(path, monitor);
	}
	} catch (CoreException ex) {
	CommonPlugin.INSTANCE.log(ex);
	if (MultiFileSaveUtil.DEBUG) {
	ex.printStackTrace();
	}
	}
	}
	}

	private void addMarker(ResolveException re, IProgressMonitor monitor) {
	InternalEObject proxy = (InternalEObject) re.getProxy();
	URI containerURI = null;
	Resource resource = null;
	if(re.getResolver() != null) {
	resource = re.getResolver().eResource();

	// make sure that resolver is still in the open library by checking whether its resource
	// still belongs to a resource set
	//
	// System.out.println("UnresolvedProxyMarkerManager.addMarker(): resourceSet=" + resource.getResourceSet().hashCode());
	if(resource != null && resource.getResourceSet() != null) {
	containerURI = resource.getURI();
	}
	}
	if (containerURI != null) {
	IWorkspace workspace = ResourcesPlugin.getWorkspace();
	IPath path = new Path(containerURI.toFileString());
	IFile file = workspace.getRoot().getFileForLocation(path);
	if (file != null) {
	String errMsg;
	if (re.exception() != null && re.exception().getLocalizedMessage() != null &&
	re.exception().getLocalizedMessage().trim().length() > 0) {
	errMsg = re.exception().getLocalizedMessage();
	}
	else {
	errMsg = re.getMessage() == null ? NLS.bind(PersistenceResources.UnresolvedProxyMarkerManager_couldNotResolveProxy, proxy.eProxyURI()) : re
	.getMessage();
	}
	addMarker(resource, proxy.eProxyURI(), errMsg, MultiFileSaveUtil.getGuid(re.getResolver()), monitor);
	}
	}
	}

	/**
	* @param marker
	* @param uri proxy uri
	*/
	private void cacheMarker(IMarker marker, URI uri) {
	synchronized(elementGUIToMarkersMap) {
	String resourceGUID = uri.authority();
	if(resourceGUID != null) {
	ValidObject vo = (ValidObject) resourceGUIToMarkersMap.get(resourceGUID);
	if(vo == null) {
	vo = new ValidObject(new HashSet());
	resourceGUIToMarkersMap.put(resourceGUID, vo);
	}
	Collection markers = (Collection) vo.object;
	markers.add(marker);
	}
	String elementGUID = uri.fragment();
	Collection markers = (Collection) elementGUIToMarkersMap.get(elementGUID);
	if(markers == null) {
	markers = new HashSet();
	elementGUIToMarkersMap.put(elementGUID, markers);
	}
	markers.add(new ValidObject(marker));
	}
	}

	public void clearAll() {
	boolean oldEnabled = enabled;
	try {
	enabled = false;
	cancel();

	synchronized (exceptions) {
	uriToExceptionsMap.clear();
	exceptions.clear();
	}
	synchronized(elementGUIToMarkersMap) {
	if(!elementGUIToMarkersMap.isEmpty()) {
	for (Iterator iter = elementGUIToMarkersMap.values().iterator(); iter.hasNext();) {
	Collection markers = (Collection) iter.next();
	for (Iterator iter1 = markers.iterator(); iter1.hasNext();) {
	ValidObject vo = (ValidObject) iter1.next();
	IMarker marker = (IMarker) vo.object;
	try {
	if(marker.exists()) {
	marker.delete();
	}
	}
	catch(Exception e) {
	CommonPlugin.INSTANCE.log(e);
	}
	}
	markers.clear();
	}
	elementGUIToMarkersMap.clear();
	resourceGUIToMarkersMap.clear();
	}
	}
	synchronized(resourcesToValidateMarkers) {
	resourcesToValidateMarkers.clear();
	}
	}
	finally {
	enabled = oldEnabled;
	// System.out.println("UnresolvedProxyMarkerManager.clearAll(): end");
	}
	}

	public boolean hasUnresolvedProxy() {
	return !elementGUIToMarkersMap.isEmpty();
	}

	private ResolveException nextException() {
	synchronized(exceptions) {
	// synchronized: in order to atomically obtain and clear requests
	if(exceptions.isEmpty()) {
	return null;
	}
	else {
	ResolveException e = (ResolveException) this.exceptions.remove(0);
	URI uri = ((InternalEObject)e.getProxy()).eProxyURI();
	Collection exceptions = (Collection) uriToExceptionsMap.get(uri);
	if(exceptions != null) {
	exceptions.remove(e);
	if(exceptions.isEmpty()) {
	uriToExceptionsMap.remove(uri);
	}
	}
	return e;
	}
	}
	}

	private Resource nextResourceToValidateMarkers() {
	synchronized(resourcesToValidateMarkers) {
	if(resourcesToValidateMarkers.isEmpty()) {
	return null;
	}
	else {
	return (Resource) resourcesToValidateMarkers.remove(0);
	}
	}
	}

	/* (non-Javadoc)
	* @see org.eclipse.core.resources.WorkspaceJob#runInWorkspace(org.eclipse.core.runtime.IProgressMonitor)
	*/
	public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
	// System.out.println("UnresolvedProxyMarkerManager.runInWorkspace(): begin");
	try {
	if(!enabled) return Status.OK_STATUS;

	try {
	// add markers
	//
	ResolveException re;
	while((re = nextException()) != null) {
	try {
	addMarker(re, monitor);
	}
	catch(Exception e) {
	CommonPlugin.INSTANCE.log(e);
	}
	}

	// remove invalid markers
	//
	removeMarkers(monitor);

	// validate resource markers
	//
	Resource resource;
	while((resource = nextResourceToValidateMarkers()) != null) {
	doValidateMarkers(resource);
	}
	}
	catch(Exception e) {
	CommonPlugin.INSTANCE.log(e);
	}

	return Status.OK_STATUS;
	}
	finally {
	// System.out.println("UnresolvedProxyMarkerManager.runInWorkspace(): end");
	}
	}

	private boolean removeFromResourceGUIDToMarkersMap(String proxyURI, IMarker marker) {
	URI uri = URI.createURI(proxyURI);
	String resourceGUID = uri.authority();
	if(resourceGUID != null) {
	ValidObject vo = (ValidObject) resourceGUIToMarkersMap.get(resourceGUID);
	if(vo != null) {
	Collection markers = ((Collection)vo.object);
	boolean ret = markers.remove(marker);
	if(markers.isEmpty()) {
	resourceGUIToMarkersMap.remove(resourceGUID);
	}
	return ret;
	}
	}
	return false;
	}

	private void removeFromElementGUIDToMarkersMap(String proxyURI, IMarker marker) {
	URI uri = URI.createURI(proxyURI);
	String elementGUID = uri.fragment();
	if(elementGUID != null) {
	Collection validObjects = (Collection) elementGUIToMarkersMap.get(elementGUID);
	if(validObjects != null) {
	for (Iterator iterator1 = validObjects.iterator(); iterator1
	.hasNext();) {
	ValidObject vo1 = (ValidObject) iterator1.next();
	if(vo1.object == marker) {
	iterator1.remove();
	}
	}
	if(validObjects.isEmpty()) {
	elementGUIToMarkersMap.remove(elementGUID);
	}
	}
	}
	}

	private void removeMarkers(IProgressMonitor monitor) {
	synchronized(elementGUIToMarkersMap) {
	for (Iterator iter = elementGUIToMarkersMap.values().iterator(); iter.hasNext();) {
	Collection markers = (Collection) iter.next();
	for (Iterator iterator = markers.iterator(); iterator.hasNext();) {
	ValidObject vo = (ValidObject) iterator.next();
	if(!vo.valid) {
	try {
	IMarker marker = (IMarker) vo.object;
	if(marker.exists()) {
	String proxyURI = (String) marker.getAttribute(PROXY_URI);

	marker.delete();

	// remove this marker from resourceGUIToMarkersMap
	//
	removeFromResourceGUIDToMarkersMap(proxyURI, marker);
	}
	iterator.remove();

	} catch (Exception e) {
	CommonPlugin.INSTANCE.log(e);
	}
	}
	}
	}
	for (Iterator iter = resourceGUIToMarkersMap.values().iterator(); iter.hasNext();) {
	ValidObject vo = (ValidObject) iter.next();
	if(!vo.valid) {
	vo.valid = true;
	Collection markers = (Collection) vo.object;
	for (Iterator iterator = markers.iterator(); iterator.hasNext();) {
	IMarker marker;
	try {
	marker = (IMarker) iterator.next();
	if(marker.exists()) {
	String proxyURIStr = (String) marker.getAttribute(PROXY_URI);
	URI proxyURI = URI.createURI(proxyURIStr);

	// proxy is in the same resource that is just loaded
	// try to get the object with this proxy URI without loading new resource
	//
	// EObject o = resourceSet.getEObject(proxyURI, false);
	String elementGUID = proxyURI.fragment();
	EObject o = (EObject) ((MultiFileResourceSetImpl)resourceSet).getGuidToMethodElementMap().get(elementGUID);
	if(o != null && !o.eIsProxy()) {
	marker.delete();
	iterator.remove();

	// remove this marker from elementGUIToMarkersMap
	//
	removeFromElementGUIDToMarkersMap(proxyURIStr, marker);
	}
	}
	else {
	iterator.remove();
	}
	}
	catch(Exception e) {
	CommonPlugin.INSTANCE.log(e);
	}
	}
	if(markers.isEmpty()) {
	iter.remove();
	}
	}
	}
	}
	}

	public void setEnabled(boolean enabled) {
	this.enabled = enabled;
	}

	/* (non-Javadoc)
	* @see org.eclipse.epf.uma.ecore.IProxyResolutionListener#notifyException(java.lang.Exception)
	*/
	public void notifyException(Exception e) {
	if(!enabled) return;

	if(e instanceof ResolveException) {
	ResolveException re = (ResolveException) e;

	// URI uri = ((InternalEObject)re.getProxy()).eProxyURI();
	// if("_2J4YoPTDEdmkpYARNN468A".equals(uri.fragment())) {
	// System.out.println();
	// }

	if(addException(re)) {
	schedule(DELAY);
	}
	}
	}

	/* (non-Javadoc)
	* @see org.eclipse.epf.uma.ecore.IProxyResolutionListener#proxyResolved(java.lang.Object, java.lang.Object)
	*/
	public void proxyResolved(Object proxy, Object resolved) {
	if(!enabled) return;

	if(proxy instanceof InternalEObject) {
	URI uri = ((InternalEObject)proxy).eProxyURI();

	// if("_2J4YoPTDEdmkpYARNN468A".equals(uri.fragment())) {
	// System.out.println();
	// }

	// remove all exceptions for this URI
	//
	removeExceptions(uri);

	// invalidate all markers for this URI
	//
	if(invalidateMarkers(uri)) {
	schedule(DELAY);
	}
	}
	}

	/**
	* @param uri
	*/
	private boolean invalidateMarkers(URI uri) {
	synchronized(elementGUIToMarkersMap) {
	boolean ret = false;
	String resourceGUID = uri.authority();
	if(resourceGUID != null) {
	ValidObject vo = (ValidObject) resourceGUIToMarkersMap.get(resourceGUID);
	if(vo != null) {
	vo.valid = false;
	ret = true;
	}
	}
	String elementGUID = uri.fragment();
	if(elementGUID != null) {
	Collection markers = (Collection) elementGUIToMarkersMap.get(elementGUID);
	if(markers != null && !markers.isEmpty()) {
	ret = true;
	for (Iterator iter = markers.iterator(); iter.hasNext();) {
	ValidObject vo = (ValidObject) iter.next();
	vo.valid = false;
	}
	}
	}
	return ret;
	}
	}

	/**
	* @param uri
	*/
	private void removeExceptions(URI uri) {
	synchronized (exceptions) {
	Collection exceptions = (Collection) uriToExceptionsMap.get(uri);
	if(exceptions == null \|\| exceptions.isEmpty()) return;
	this.exceptions.removeAll(exceptions);
	uriToExceptionsMap.remove(uri);
	}
	}

	/**
	* Clears markers for unresolved proxies of the given resource
	*
	* @param resource
	*/
	public void clearMarkers(Resource resource) {
	try {
	IResource file = FileManager.getResourceForLocation(resource.getURI().toFileString());
	if(file instanceof IFile) {
	IMarker[] markers = file.findMarkers(IMarker.PROBLEM, false, IResource.DEPTH_ZERO);
	for (int i = 0; i < markers.length; i++) {
	IMarker marker = markers[i];
	removeMarker(marker);
	}
	}
	}
	catch(Exception e) {
	PersistencePlugin.getDefault().getLogger().logError(e);
	}
	}

	public void removeMarker(IMarker marker) {
	String proxyURI = null;
	try {
	if(marker.exists()) {
	proxyURI = (String) marker.getAttribute(PROXY_URI);
	marker.delete();
	}
	} catch (Exception e) {
	PersistencePlugin.getDefault().getLogger().logError(e);
	}
	if(proxyURI != null) {
	synchronized(elementGUIToMarkersMap) {
	removeFromElementGUIDToMarkersMap(proxyURI, marker);
	removeFromResourceGUIDToMarkersMap(proxyURI, marker);
	}
	}
	}

	private static class MarkerInfo {
	String proxyURI;
	String ownerGUID;
	String message;

	/* (non-Javadoc)
	* @see java.lang.Object#equals(java.lang.Object)
	*/
	public boolean equals(Object obj) {
	if(obj instanceof MarkerInfo) {
	MarkerInfo info = (MarkerInfo) obj;
	if(proxyURI != null && ownerGUID != null && proxyURI.equals(info.proxyURI) && ownerGUID.equals(info.ownerGUID)) {
	return true;
	}
	}
	return super.equals(obj);
	}
	}

	/**
	* Validates markers for unresolved proxies of the given resource
	*
	* @param resource
	*/
	public void validateMarkers(Resource resource) {
	boolean newlyAdded = false;
	synchronized(resourcesToValidateMarkers) {
	newlyAdded = resourcesToValidateMarkers.add(resource);
	}
	if(newlyAdded) {
	schedule(DELAY);
	}
	}

	private void doValidateMarkers(Resource resource) {
	try {
	IResource file = FileManager.getResourceForLocation(resource.getURI().toFileString());
	if(file instanceof IFile) {
	IMarker[] markers = file.findMarkers(IMarker.PROBLEM, false, IResource.DEPTH_ZERO);
	HashSet markerInfos = new HashSet();
	for (int i = 0; i < markers.length; i++) {
	IMarker marker = markers[i];
	String proxyURI = (String) marker.getAttribute(PROXY_URI);
	if(proxyURI != null) {
	URI uri = URI.createURI(proxyURI);
	// try to get the object with this proxy URI without loading new resource
	//
	String elementGUID = uri.fragment();
	EObject o = (EObject) ((MultiFileResourceSetImpl)resourceSet).getGuidToMethodElementMap().get(elementGUID);
	if(o == null \|\| o.eIsProxy()) {
	MarkerInfo info = new MarkerInfo();
	info.message = (String) marker.getAttribute(IMarker.MESSAGE);
	info.ownerGUID = (String) marker.getAttribute(OWNER_GUID);
	info.proxyURI = proxyURI;
	markerInfos.add(info);
	}

	if(marker.exists()) {
	try {
	marker.delete();
	}
	catch(Exception e) {
	PersistencePlugin.getDefault().getLogger().logError(e);
	}
	}
	synchronized(elementGUIToMarkersMap) {
	removeFromElementGUIDToMarkersMap(proxyURI, marker);
	removeFromResourceGUIDToMarkersMap(proxyURI, marker);
	}

	}
	}
	if(!markerInfos.isEmpty()) {
	for (Iterator iter = markerInfos.iterator(); iter.hasNext();) {
	MarkerInfo info = (MarkerInfo) iter.next();
	addMarker(resource, URI.createURI(info.proxyURI), info.message, info.ownerGUID, new NullProgressMonitor());
	}
	}
	}
	}
	catch(Exception e) {
	PersistencePlugin.getDefault().getLogger().logError(e);
	}
	}

	}