/******************************************************************************
* Copyright (c) 2005, 2006 BEA Systems, Inc.
* 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:
* Konstantin Komissarchik - initial API and implementation
******************************************************************************/
package org.eclipse.jst.common.jdt.internal.classpath;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IProject;
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.IResourceDeltaVisitor;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jdt.core.IAccessRule;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jst.common.frameworks.CommonFrameworksPlugin;
import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyComponent;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.ModuleCoreNature;
import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.componentcore.resources.IVirtualResource;
/**
* @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
*/
public abstract class FlexibleProjectContainer
implements IClasspathContainer
{
protected static final class PathType
{
public static final PathType
LIB_DIRECTORY = new PathType(),
CLASSES_DIRECTORY = new PathType();
}
private static ClasspathDecorationsManager decorations;
static
{
// Register the resource listener that will listen for changes to
// resources relevant to flexible project containers across the
// workspace and refresh them as necessary.
Listener.register();
// Read the decorations from the workspace metadata.
final String plugin = CommonFrameworksPlugin.PLUGIN_ID;
decorations = new ClasspathDecorationsManager( plugin );
}
private static final String SEPARATOR = "!"; //$NON-NLS-1$
public static String getDecorationManagerKey(IProject project, String container){
return project.getName() + SEPARATOR + container;
}
protected final IPath path;
protected final IJavaProject owner;
protected final IProject project;
private final IPath[] paths;
private final PathType[] pathTypes;
protected final List entries;
private final IClasspathEntry[] cpentries;
private static final Set containerTypes = new HashSet();
public FlexibleProjectContainer( final IPath path,
final IJavaProject owner,
final IProject project,
final IPath[] paths,
final PathType[] types )
{
this.path = path;
this.owner = owner;
this.project = project;
this.paths = paths;
this.pathTypes = types;
if( ! isFlexibleProject( this.project ) )
{
// Silently noop if the referenced project is not a flexible
// project. Should I be doing something else here?
this.entries = Collections.EMPTY_LIST;
this.cpentries = new IClasspathEntry[ 0 ];
return;
}
addFlexibleProjectContainerType( path.segment( 0 ) );
this.entries = computeClasspathEntries();
this.cpentries = new IClasspathEntry[ this.entries.size() ];
for( int i = 0, n = this.entries.size(); i < n; i++ )
{
IPath entryPath = (IPath) this.entries.get( i );
IResource resource =ResourcesPlugin.getWorkspace().getRoot().findMember(entryPath);
if(null != resource && resource.getType() == IResource.PROJECT)
this.cpentries[ i ] = JavaCore.newProjectEntry(entryPath, false);
else
this.cpentries[ i ] = newLibraryEntry( entryPath );
}
}
public int getKind()
{
return K_APPLICATION;
}
public IPath getPath()
{
return this.path;
}
public IClasspathEntry[] getClasspathEntries()
{
return this.cpentries;
}
public boolean isOutOfDate( final IResourceDelta delta )
{
if( delta == null )
{
return false;
}
return isOutOfDate();
}
public boolean isOutOfDate() {
final List currentEntries = computeClasspathEntries();
return ! this.entries.equals( currentEntries );
}
public abstract void refresh();
/**
* If forceUpdate is <code>false</code> then a refresh is made only if
* {@link #isOutOfDate()} returns <code>true</code>. If forceUpdate is
* <code>true</code> then a refresh is immediately made without checking
* {@link #isOutOfDate()}.
*
* @param forceUpdate
*/
public void refresh(boolean forceUpdate){
if(forceUpdate || isOutOfDate()){
refresh();
}
}
static ClasspathDecorationsManager getDecorationsManager()
{
return decorations;
}
protected IVirtualReference [] computeReferences(IVirtualComponent vc){
return vc.getReferences();
}
protected List computeClasspathEntries()
{
final List entries = new ArrayList();
final IVirtualComponent vc
= ComponentCore.createComponent( this.project );
if( vc == null )
{
return entries;
}
IVirtualReference[] refs = computeReferences(vc);
IVirtualComponent comp = null;
Set jarsHandled = new HashSet();
String jarName = null;
for (int i = 0; i < refs.length; i++) {
comp = refs[i].getReferencedComponent();
if (!refs[i].getRuntimePath().equals(paths[0].makeAbsolute()))
continue;
jarName = refs[i].getArchiveName();
if(null != jarName){
jarsHandled.add(jarName);
}
IPath newPath = null;
if (comp.isBinary()) {
if( comp instanceof IClasspathDependencyComponent )
continue;
newPath = (IPath)comp.getAdapter(IPath.class);
} else
newPath = comp.getProject().getFullPath();
if( newPath != null && !entries.contains(newPath))
entries.add( newPath );
}
for( int i = 0; i < this.paths.length; i++ )
{
final IVirtualFolder rootFolder = vc.getRootFolder();
final IVirtualFolder vf = rootFolder.getFolder( paths[ i ] );
if( this.pathTypes[ i ] == PathType.LIB_DIRECTORY )
{
final IVirtualResource[] contents;
try
{
contents = members( vf );
}
catch( CoreException e )
{
CommonFrameworksPlugin.log( e );
continue;
}
for( int j = 0; j < contents.length; j++ )
{
final IResource r = contents[ j ].getUnderlyingResource();
final IPath p = r.getLocation();
if(!jarsHandled.contains(p.lastSegment()) && isJarFile( r ) )
{
jarsHandled.add(p.lastSegment());
entries.add( p );
}
}
}
else
{
final IContainer[] uf = vf.getUnderlyingFolders();
for( int j = 0; j < uf.length; j++ )
{
final IPath p = uf[ j ].getFullPath();
if( ! jarsHandled.contains( p.lastSegment() ) &&
! isSourceOrOutputDirectory( p ) )
{
jarsHandled.add(p.lastSegment());
entries.add( p );
}
}
}
}
return entries;
}
// TODO: This method was created to provide a safe last-minute workaround
// for the issue described in https://bugs.eclipse.org/bugs/show_bug.cgi?id=162974.
// This code needs to be revisited in a future release to find a more
// permanent solution.
protected IVirtualResource[] members( final IVirtualFolder vf )
throws CoreException
{
return vf.members();
}
private IClasspathEntry newLibraryEntry( final IPath p )
{
IPath srcpath = null;
IPath srcrootpath = null;
IClasspathAttribute[] attrs = {};
IAccessRule[] access = {};
final ClasspathDecorations dec
= decorations.getDecorations( getDecorationManagerKey(project, getPath().toString()), p.toString() );
if( dec != null )
{
srcpath = dec.getSourceAttachmentPath();
srcrootpath = dec.getSourceAttachmentRootPath();
attrs = dec.getExtraAttributes();
}
return JavaCore.newLibraryEntry( p, srcpath, srcrootpath, access, attrs,
false );
}
private boolean isSourceOrOutputDirectory( final IPath aPath )
{
if( isJavaProject( this.project ) )
{
try
{
final IJavaProject jproject = JavaCore.create( this.project );
final IClasspathEntry[] cp = jproject.getRawClasspath();
for( int i = 0; i < cp.length; i++ )
{
final IClasspathEntry cpe = cp[ i ];
if( cpe.getEntryKind() == IClasspathEntry.CPE_SOURCE )
{
final IPath src = cpe.getPath();
final IPath output = cpe.getOutputLocation();
if( src.equals( aPath ) ||
output != null && output.equals( aPath ) )
{
return true;
}
}
}
if( jproject.getOutputLocation().equals( aPath ) )
{
return true;
}
}
catch( JavaModelException e )
{
CommonFrameworksPlugin.log( e );
}
}
return false;
}
private static boolean isJavaProject( final IProject pj )
{
try
{
return pj.getNature( JavaCore.NATURE_ID ) != null;
}
catch( CoreException e )
{
return false;
}
}
private static boolean isFlexibleProject( final IProject pj )
{
try
{
return pj.getNature( IModuleConstants.MODULE_NATURE_ID ) != null;
}
catch( CoreException e )
{
return false;
}
}
private static boolean isJarFile( final IResource f )
{
if( f.getType() == IResource.FILE )
{
final String fname = f.getName();
if( fname.endsWith( ".jar" ) || fname.endsWith( ".zip" ) ) //$NON-NLS-1$ //$NON-NLS-2$
{
return true;
}
}
return false;
}
private static boolean isMetadataFile( final IResource f )
{
if( f.getType() == IResource.FILE )
{
final String fname = f.getName();
if( fname.equals( ".component" ) || //$NON-NLS-1$
fname.equals( "org.eclipse.wst.common.component" ) || //$NON-NLS-1$
fname.equals( ".classpath")) //$NON-NLS-1$
{
return true;
}
}
return false;
}
private static boolean isFlexibleProjectContainer( final IPath path )
{
synchronized( containerTypes )
{
return containerTypes.contains( path.segment( 0 ) );
}
}
private static void addFlexibleProjectContainerType( final String type )
{
synchronized( containerTypes )
{
containerTypes.add( type );
}
}
private static final class Listener
implements IResourceChangeListener
{
public static void register()
{
final Listener listener = new Listener();
final IWorkspace ws = ResourcesPlugin.getWorkspace();
ws.addResourceChangeListener( listener, IResourceChangeEvent.PRE_BUILD );
}
public void resourceChanged( final IResourceChangeEvent event )
{
// Screen the delta before going any further.
if( ! isInterestingEvent( event ) )
{
return;
}
// Locate all of the flexible project containers.
final ArrayList containers = new ArrayList();
final IProject[] projects
= ResourcesPlugin.getWorkspace().getRoot().getProjects();
for( int i = 0; i < projects.length; i++ )
{
final IProject project = projects[ i ];
try
{
if( isJavaProject( project ) )
{
final IJavaProject jproj = JavaCore.create( project );
final IClasspathEntry[] cpes = jproj.getRawClasspath();
for( int j = 0; j < cpes.length; j++ )
{
final IClasspathEntry cpe = cpes[ j ];
final IPath path = cpe.getPath();
if( cpe.getEntryKind() == IClasspathEntry.CPE_CONTAINER &&
isFlexibleProjectContainer( path ) )
{
final IClasspathContainer cont
= JavaCore.getClasspathContainer( path, jproj );
containers.add( cont );
}
}
}
}
catch( JavaModelException e )
{
CommonFrameworksPlugin.log( e );
}
}
// Refresh the containers that are out of date.
final IResourceDelta delta = event.getDelta();
for( int i = 0, n = containers.size(); i < n; i++ )
{
final FlexibleProjectContainer c
= (FlexibleProjectContainer) containers.get( i );
if( c.isOutOfDate( delta ) )
{
c.refresh();
}
}
}
private static boolean isInterestingEvent( final IResourceChangeEvent event )
{
final boolean[] result = new boolean[ 1 ];
final IResourceDeltaVisitor visitor = new IResourceDeltaVisitor()
{
public boolean visit( final IResourceDelta delta )
{
final IResource r = delta.getResource();
switch( r.getType() )
{
case IResource.ROOT:
{
return true;
}
case IResource.PROJECT:
{
return ModuleCoreNature.isFlexibleProject( (IProject) r );
}
case IResource.FOLDER:
{
final int kind = delta.getKind();
if( kind == IResourceDelta.ADDED ||
kind == IResourceDelta.REMOVED )
{
result[ 0 ] = true;
return false;
}
return true;
}
case IResource.FILE:
{
if( isJarFile( r ) || isMetadataFile( r ) )
{
result[ 0 ] = true;
}
return false;
}
default:
{
return false;
}
}
}
};
try
{
event.getDelta().accept( visitor, false );
}
catch( CoreException e )
{
CommonFrameworksPlugin.log( e );
}
return result[ 0 ];
}
}
}