| package org.eclipse.jst.jsf.designtime.internal.resources; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.jst.jsf.common.internal.componentcore.AbstractVirtualComponentQuery; |
| import org.eclipse.jst.jsf.common.internal.finder.AbstractMatcher.AlwaysMatcher; |
| import org.eclipse.jst.jsf.common.internal.finder.VisitorMatcher; |
| import org.eclipse.jst.jsf.common.internal.finder.acceptor.FileMatchingAcceptor; |
| import org.eclipse.jst.jsf.common.internal.resource.ContentTypeResolver; |
| import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent; |
| import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent.ReasonType; |
| import org.eclipse.jst.jsf.common.internal.resource.ResourceManager; |
| import org.eclipse.jst.jsf.common.internal.resource.ResourceTracker; |
| import org.eclipse.jst.jsf.core.internal.JSFCorePlugin; |
| import org.eclipse.jst.jsf.designtime.internal.resources.JSFResourceChangeListener.JSFResourceChangedEvent; |
| import org.eclipse.jst.jsf.designtime.internal.resources.JSFResourceChangeListener.JSFResourceChangedEvent.CHANGE_TYPE; |
| import org.eclipse.jst.jsf.designtime.internal.resources.ResourceIdentifierFactory.InvalidIdentifierException; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualFolder; |
| |
| /** |
| * Resource Manager that tracks JSF resources in a workspace. |
| * |
| * @author cbateman |
| * |
| */ |
| public class WorkspaceResourceManager extends ResourceManager<IResource> |
| { |
| private final AbstractVirtualComponentQuery _vcQuery; |
| private final IProject _project; |
| private final AbstractJSFResourceLocator _locator; |
| private final ContentTypeResolver _contentTypeResolver; |
| private final ResourceIdentifierFactory _factory; |
| |
| /** |
| * @param project |
| * @param vcQuery |
| * @param locator |
| * @param contentTypeResolver |
| */ |
| public WorkspaceResourceManager(final IProject project, |
| final AbstractVirtualComponentQuery vcQuery, |
| final AbstractJSFResourceLocator locator, |
| final ContentTypeResolver contentTypeResolver) |
| { |
| super(project.getWorkspace()); |
| _project = project; |
| _vcQuery = vcQuery; |
| _locator = locator; |
| _contentTypeResolver = contentTypeResolver; |
| _factory = new ResourceIdentifierFactory(); |
| } |
| |
| @Override |
| protected JSFResourceTracker createNewInstance(final IResource resource) |
| { |
| final boolean isJSFResource = !getRootResourceFolder().getParent() |
| .equals(resource); |
| return new JSFResourceTracker(resource, isJSFResource); |
| } |
| |
| @Override |
| public void initResources() |
| { |
| final IFolder folder = getRootResourceFolder(); |
| if (folder != null) |
| { |
| try |
| { |
| track(folder.getParent()); |
| track(folder); |
| } catch (final Exception e1) |
| { |
| JSFCorePlugin |
| .log(e1, |
| "While trying to locate JSF resources in the workspace"); //$NON-NLS-1$ |
| } |
| if (folder.isAccessible()) |
| { |
| trackAllInFolder(folder); |
| } |
| } |
| } |
| |
| private List<IWorkspaceJSFResourceFragment> trackAllInFolder( |
| final IContainer folder) |
| { |
| final VisitorMatcher<IContainer, IResource, String> matcher = new VisitorMatcher<IContainer, IResource, String>( |
| "", "", //$NON-NLS-1$ //$NON-NLS-2$ |
| new FileMatchingAcceptor(), |
| Collections.singletonList(new AlwaysMatcher())); |
| final List<IWorkspaceJSFResourceFragment> newFragments = new ArrayList<IWorkspaceJSFResourceFragment>(); |
| try |
| { |
| final Collection<? extends IResource> foundResources = matcher |
| .find(folder); |
| for (final IResource res : foundResources) |
| { |
| try |
| { |
| newFragments.add(track(res)); |
| } catch (final InvalidIdentifierException e) |
| { |
| JSFCorePlugin.log(IStatus.INFO, |
| "Ignoring invalid JSF resource: "+res); //$NON-NLS-1$ |
| } |
| catch (final ManagedObjectException e) |
| { |
| JSFCorePlugin.log(e, |
| "Problem adding managed object for resource: "+res); //$NON-NLS-1$ |
| } |
| } |
| } catch (final Exception e) |
| { |
| JSFCorePlugin.log(e, |
| "While trying to locate JSF resources in the workspace"); //$NON-NLS-1$ |
| } |
| return newFragments; |
| } |
| |
| private IWorkspaceJSFResourceFragment track(final IResource res) |
| throws ManagedObjectException, InvalidIdentifierException |
| { |
| final IPath fullPath = res.getFullPath().makeRelativeTo( |
| getRootResourceFolder().getFullPath()); |
| // cause the resource to get tracked |
| final JSFResourceTracker tracker = (JSFResourceTracker) getInstance(res); |
| IWorkspaceJSFResourceFragment jsfRes = null; |
| if (res.getType() == IResource.FILE) |
| { |
| try |
| { |
| jsfRes = new WorkspaceJSFResource( |
| _factory.createLibraryResource(fullPath.toString()), res, |
| _contentTypeResolver); |
| } |
| catch (InvalidIdentifierException e) |
| { |
| // ensure that the tracker gets released before we throw the exception. |
| unmanageResource(res); |
| tracker.dispose(); |
| throw e; |
| } |
| } else |
| { |
| jsfRes = new WorkspaceJSFResourceContainer( |
| _factory.createLibraryFragment(fullPath.toString()), |
| (IContainer) res); |
| } |
| tracker.setJsfResource(jsfRes); |
| addLifecycleEventListener(tracker); |
| return jsfRes; |
| } |
| |
| /** |
| * @return the root folder for resources in the workspace. |
| */ |
| public IFolder getRootResourceFolder() |
| { |
| final IVirtualFolder webContentFolder = _vcQuery |
| .getWebContentFolder(_project); |
| if (webContentFolder != null |
| && webContentFolder.getUnderlyingFolder().isAccessible()) |
| { |
| return webContentFolder.getUnderlyingFolder().getFolder( |
| new Path("resources")); //$NON-NLS-1$ |
| } |
| return null; |
| } |
| |
| @Override |
| public List<IResource> getResources() |
| { |
| return new ArrayList(getManagedResources()); |
| } |
| |
| /** |
| * @return the jsf resource currently known. List is a copy but the |
| * contained JSFResource references are not. |
| */ |
| public List<IJSFResourceFragment> getJSFResources() |
| { |
| final List<IJSFResourceFragment> jsfResources = new ArrayList<IJSFResourceFragment>(); |
| final Map<IResource, ManagedResourceObject<ResourceTracker<IResource>>> jsfResourceTrackers = getPerResourceObjects(); |
| for (final Map.Entry<IResource, ManagedResourceObject<ResourceTracker<IResource>>> entry : jsfResourceTrackers |
| .entrySet()) |
| { |
| final JSFResourceTracker jsfResourceTracker = (JSFResourceTracker) entry |
| .getValue().getManagedObject(); |
| if (jsfResourceTracker.isJSFResource()) |
| { |
| jsfResources.add(jsfResourceTracker.getJsfResource()); |
| } |
| } |
| return jsfResources; |
| } |
| |
| private class JSFResourceTracker extends ResourceTracker<IResource> |
| { |
| private IWorkspaceJSFResourceFragment _jsfResource; |
| private final boolean _isJSFResource; |
| |
| /** |
| * @param resource |
| * @param isJSFResource |
| * if false, indicates that the resource being tracked is |
| * related to JSF resources but not an actual JSF resource |
| * (i.e. web root). |
| */ |
| public JSFResourceTracker(final IResource resource, |
| final boolean isJSFResource) |
| { |
| super(resource); |
| _isJSFResource = isJSFResource; |
| } |
| |
| public boolean isJSFResource() |
| { |
| return _isJSFResource; |
| } |
| |
| @Override |
| protected void fireResourceInAccessible( |
| final IResource affectedResource, final ReasonType reasonType) |
| { |
| if (reasonType == ReasonType.RESOURCE_DELETED_FROM_CONTAINER |
| || reasonType == ReasonType.RESOURCE_MOVED_CONTAINER) |
| { |
| try |
| { |
| final List<JSFResourceTracker> trackers = getTrackers(affectedResource); |
| for (final JSFResourceTracker tracker : trackers) |
| { |
| final IWorkspaceJSFResourceFragment jsfResource = tracker |
| .getJsfResource(); |
| removeLifecycleEventListener(tracker); |
| _locator.fireChangeEvent(new JSFResourceChangedEvent( |
| _locator, jsfResource, null, |
| CHANGE_TYPE.REMOVED)); |
| } |
| } catch (final ManagedObjectException e) |
| { |
| JSFCorePlugin.log(e, |
| "Processing an inaccessible resource event"); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| private List<JSFResourceTracker> getTrackers(final IResource res) |
| throws ManagedObjectException |
| { |
| final JSFResourceTracker tracker = (JSFResourceTracker) getInstance(res); |
| final List<JSFResourceTracker> allChildren = new ArrayList<JSFResourceTracker>(); |
| allChildren.add(tracker); |
| if (res instanceof IContainer) |
| { |
| final IPath parentPath = res.getFullPath(); |
| for (final Entry<IResource, ManagedResourceObject<ResourceTracker<IResource>>> trackerEntry : getPerResourceObjects() |
| .entrySet()) |
| { |
| final IPath trackerPath = trackerEntry.getKey() |
| .getFullPath(); |
| if (parentPath.isPrefixOf(trackerPath) |
| && !parentPath.equals(trackerPath)) |
| { |
| allChildren.add((JSFResourceTracker) trackerEntry |
| .getValue().getManagedObject()); |
| } |
| } |
| } |
| return allChildren; |
| } |
| |
| @Override |
| protected void fireResourceChanged(final IResource affectedResource, |
| final ReasonType reasonType) |
| { |
| _locator.fireChangeEvent(new JSFResourceChangedEvent(_locator, |
| _jsfResource, _jsfResource, CHANGE_TYPE.CHANGED)); |
| } |
| |
| @Override |
| protected void fireResourceAdded(final IResource affectedResource, |
| final ReasonType reasonType) |
| { |
| if (reasonType == ReasonType.RESOURCE_ADDED_TO_CONTAINER |
| || reasonType == ReasonType.RESOURCE_MOVED_CONTAINER) |
| { |
| final IContainer parent = affectedResource.getParent(); |
| if (parent != null && parent.isAccessible()) |
| { |
| try |
| { |
| final IWorkspaceJSFResourceFragment newJsfRes = track(affectedResource); |
| fireNewJSFResourceEvent(newJsfRes); |
| if (reasonType == ReasonType.RESOURCE_MOVED_CONTAINER |
| && affectedResource instanceof IContainer) |
| { |
| final List<IWorkspaceJSFResourceFragment> newFragments = trackAllInFolder((IContainer) affectedResource); |
| for (final IWorkspaceJSFResourceFragment frag : newFragments) |
| { |
| fireNewJSFResourceEvent(frag); |
| } |
| } |
| } catch (final ManagedObjectException e) |
| { |
| JSFCorePlugin |
| .log(e, |
| "While adding new resource " + affectedResource); //$NON-NLS-1$ |
| } catch (final InvalidIdentifierException e) |
| { |
| JSFCorePlugin |
| .log(IStatus.INFO, |
| "While adding new resource " + affectedResource); //$NON-NLS-1$ |
| } |
| } |
| } |
| } |
| |
| private void fireNewJSFResourceEvent( |
| final IWorkspaceJSFResourceFragment newJsfRes) |
| { |
| final JSFResourceChangedEvent event = new JSFResourceChangedEvent( |
| _locator, null, newJsfRes, CHANGE_TYPE.ADDED); |
| _locator.fireChangeEvent(event); |
| } |
| |
| @Override |
| protected boolean isInteresting(final ResourceLifecycleEvent event) |
| { |
| boolean isInteresting = false; |
| final ReasonType reasonType = event.getReasonType(); |
| switch (event.getEventType()) |
| { |
| case RESOURCE_ADDED: |
| { |
| final IResource resource = getResource(); |
| isInteresting = (reasonType == ReasonType.RESOURCE_ADDED_TO_CONTAINER || reasonType == ReasonType.RESOURCE_MOVED_CONTAINER) |
| && event.getAffectedResource().getParent() |
| .equals(resource); |
| // ignore if my resource is web content and this is trying |
| // to add something other than resources folder |
| if (resource.equals(_vcQuery.getWebContentFolder(_project) |
| .getUnderlyingFolder())) |
| { |
| isInteresting &= event.getAffectedResource().equals( |
| getRootResourceFolder()); |
| } |
| } |
| break; |
| case RESOURCE_INACCESSIBLE: |
| { |
| final IResource resource = getResource(); |
| // if the resource made inaccessible was deleted or moved |
| // from its container |
| // and it's parent is me, then it is interesting. |
| isInteresting = (reasonType == ReasonType.RESOURCE_DELETED_FROM_CONTAINER || reasonType == ReasonType.RESOURCE_MOVED_CONTAINER) |
| && event.getAffectedResource().getParent() |
| .equals(resource); |
| // ignore if my resource is web content and this is trying |
| // to add something other than resources folder |
| if (resource.equals(_vcQuery.getWebContentFolder(_project) |
| .getUnderlyingFolder())) |
| { |
| isInteresting &= event.getAffectedResource().equals( |
| getRootResourceFolder()); |
| } |
| // isInteresting &= (_isJSFResource || (resource.getType() == IResource.FOLDER && "resources".equals(resource.getName()))); //$NON-NLS-1$ |
| // or if the resource being delted or moved is the root |
| // folder and that is my resource. |
| // isInteresting |= (reasonType == |
| // ReasonType.RESOURCE_DELETED || reasonType == |
| // ReasonType.RESOURCE_MOVED_CONTAINER) |
| // && (resource.equals(event.getAffectedResource()) && |
| // resource.equals(getRootResourceFolder())); |
| } |
| break; |
| default: |
| isInteresting = super.isInteresting(event); |
| } |
| return isInteresting; |
| } |
| |
| public final IWorkspaceJSFResourceFragment getJsfResource() |
| { |
| return _jsfResource; |
| } |
| |
| public final void setJsfResource( |
| final IWorkspaceJSFResourceFragment jsfResource) |
| { |
| _jsfResource = jsfResource; |
| } |
| } |
| } |
