/******************************************************************************
* Copyright (c) 2005, 2007 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
******************************************************************************/
package org.eclipse.jst.j2ee.internal.archive;
import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.findExtensions;
import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.findOptionalElement;
import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.findRequiredAttribute;
import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.findRequiredElement;
import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.getTopLevelElements;
import static org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.instantiate;
import static org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.PLUGIN_ID;
import static org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.createErrorStatus;
import static org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.log;
import static org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.eclipse.core.expressions.EvaluationContext;
import org.eclipse.core.expressions.EvaluationResult;
import org.eclipse.core.expressions.Expression;
import org.eclipse.core.expressions.ExpressionConverter;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jst.j2ee.archive.IArchiveExportParticipant;
import org.eclipse.jst.j2ee.internal.archive.ArchiveExportParticipantsExtensionPoint.PluginUtil.InvalidExtensionException;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntimeComponent;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntimeComponentType;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntimeComponentVersion;
import org.eclipse.wst.common.project.facet.core.runtime.RuntimeManager;
import org.osgi.framework.Bundle;
/**
* Contains the logic for processing the <code>org.eclipse.jst.j2ee.archiveExportParticipants</code>
* extension point.
*
* @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
*/
public final class ArchiveExportParticipantsExtensionPoint
{
public static final String EXTENSION_POINT_ID = "archiveExportParticipants"; //$NON-NLS-1$
private static final String EL_PARTICIPANT = "participant"; //$NON-NLS-1$
private static final String EL_RUNTIME_COMPONENT = "runtime-component"; //$NON-NLS-1$
private static final String EL_FACTORY = "factory"; //$NON-NLS-1$
private static final String EL_ENABLEMENT = "enablement"; //$NON-NLS-1$
private static final String ATTR_ID = "id"; //$NON-NLS-1$
private static final String ATTR_TYPE = "type"; //$NON-NLS-1$
private static final String ATTR_VERSION = "version"; //$NON-NLS-1$
private static final String ATTR_CLASS = "class"; //$NON-NLS-1$
private static List<ParticipantInfo> extensions = null;
public static class ParticipantInfo
{
private String id;
private String pluginId = null;
private String className = null;
private IRuntimeComponentType runtimeComponentType = null;
private String runtimeComponentVersionExpr = null;
private Expression enablementCondition = null;
public String getId()
{
return this.id;
}
public IArchiveExportParticipant loadParticipant()
{
try
{
return instantiate( this.pluginId, this.className, IArchiveExportParticipant.class );
}
catch( CoreException e )
{
log( e.getStatus() );
return null;
}
}
}
public static List<ParticipantInfo> getExtensions( final IProject project,
final IRuntime runtime )
{
readExtensions();
final List<ParticipantInfo> result = new ArrayList<ParticipantInfo>();
for( ParticipantInfo partInfo : extensions )
{
boolean match = false;
for( IRuntimeComponent rc : runtime.getRuntimeComponents() )
{
final IRuntimeComponentType rct = rc.getRuntimeComponentType();
if( rct == partInfo.runtimeComponentType )
{
final IRuntimeComponentVersion rcv = rc.getRuntimeComponentVersion();
try
{
if( rct.getVersions( partInfo.runtimeComponentVersionExpr ).contains( rcv ) )
{
match = true;
break;
}
}
catch( CoreException e )
{
logError( -1, e.getMessage(), e );
}
}
}
if( match && partInfo.enablementCondition != null )
{
final EvaluationContext evalContext = new EvaluationContext( null, project );
evalContext.setAllowPluginActivation( true );
try
{
final EvaluationResult evalResult
= partInfo.enablementCondition.evaluate( evalContext );
if( evalResult != EvaluationResult.TRUE )
{
match = false;
}
}
catch( CoreException e )
{
logError( -1, e.getMessage(), e );
}
}
if( match )
{
result.add( partInfo );
}
}
return Collections.unmodifiableList( result );
}
private static synchronized void readExtensions()
{
if( extensions != null )
{
return;
}
extensions = new ArrayList<ParticipantInfo>();
for( IConfigurationElement element
: getTopLevelElements( findExtensions( PLUGIN_ID, EXTENSION_POINT_ID ) ) )
{
if( element.getName().equals( EL_PARTICIPANT ) )
{
try
{
readExtension( element );
}
catch( InvalidExtensionException e )
{
// Continue. The problem has been reported to the user via the log.
}
}
}
}
private static void readExtension( final IConfigurationElement config )
throws InvalidExtensionException
{
final ParticipantInfo info = new ParticipantInfo();
info.pluginId = config.getContributor().getName();
info.id = info.pluginId + "." + findRequiredAttribute( config, ATTR_ID ); //$NON-NLS-1$
final IConfigurationElement elFactory = findRequiredElement( config, EL_FACTORY );
info.className = findRequiredAttribute( elFactory, ATTR_CLASS );
final IConfigurationElement elRuntimeComponent
= findRequiredElement( config, EL_RUNTIME_COMPONENT );
final String rcTypeString = findRequiredAttribute( elRuntimeComponent, ATTR_TYPE );
if( ! RuntimeManager.isRuntimeComponentTypeDefined( rcTypeString ) )
{
// TODO: Log the problem
throw new InvalidExtensionException();
}
info.runtimeComponentType = RuntimeManager.getRuntimeComponentType( rcTypeString );
info.runtimeComponentVersionExpr = elRuntimeComponent.getAttribute( ATTR_VERSION );
final IConfigurationElement elEnablement = findOptionalElement( config, EL_ENABLEMENT );
try
{
info.enablementCondition = ExpressionConverter.getDefault().perform( elEnablement );
}
catch( CoreException e )
{
logError( -1, e.getMessage(), e );
throw new InvalidExtensionException();
}
extensions.add( info );
}
/**
* Utility methods that are helpful for implementing extension points.
*
* @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
*/
public static final class PluginUtil
{
public static final class InvalidExtensionException
extends Exception
{
private static final long serialVersionUID = 1L;
}
private PluginUtil() {}
public static Collection<IExtension> findExtensions( final String pluginId,
final String extensionPointId )
{
final IExtensionRegistry registry = Platform.getExtensionRegistry();
final IExtensionPoint point = registry.getExtensionPoint( pluginId, extensionPointId );
if( point == null )
{
throw new RuntimeException();
}
final List<IExtension> extensions = new ArrayList<IExtension>();
for( IExtension extension : point.getExtensions() )
{
extensions.add( extension );
}
return extensions;
}
public static Collection<IConfigurationElement> getTopLevelElements( final Collection<IExtension> extensions )
{
final List<IConfigurationElement> elements = new ArrayList<IConfigurationElement>();
for( IExtension extension : extensions )
{
for( IConfigurationElement element : extension.getConfigurationElements() )
{
elements.add( element );
}
}
return elements;
}
public static void reportMissingAttribute( final IConfigurationElement el,
final String attribute )
{
final String pluginId = el.getContributor().getName();
final String extPointId = el.getDeclaringExtension().getExtensionPointUniqueIdentifier();
final String msg
= Resources.bind( Resources.missingAttribute, pluginId, extPointId, el.getName(),
attribute );
log( createErrorStatus( -1, msg, null ) );
}
public static void reportMissingElement( final IConfigurationElement el,
final String element )
{
final String pluginId = el.getContributor().getName();
final String extPointId = el.getDeclaringExtension().getExtensionPointUniqueIdentifier();
final String msg
= Resources.bind( Resources.missingElement, pluginId, extPointId, el.getName(),
element );
log( createErrorStatus( -1, msg, null ) );
}
public static String findRequiredAttribute( final IConfigurationElement el,
final String attribute )
throws InvalidExtensionException
{
final String val = el.getAttribute( attribute );
if( val == null )
{
reportMissingAttribute( el, attribute );
throw new InvalidExtensionException();
}
return val;
}
public static IConfigurationElement findRequiredElement( final IConfigurationElement el,
final String childElement )
throws InvalidExtensionException
{
final IConfigurationElement[] children = el.getChildren( childElement );
if( children.length == 0 )
{
reportMissingElement( el, childElement );
throw new InvalidExtensionException();
}
return children[ 0 ];
}
public static IConfigurationElement findOptionalElement( final IConfigurationElement el,
final String childElement )
{
final IConfigurationElement[] children = el.getChildren( childElement );
if( children.length == 0 )
{
return null;
}
return children[ 0 ];
}
public static String getElementValue( final IConfigurationElement el,
final String defaultValue )
{
if( el != null )
{
String text = el.getValue();
if( text != null )
{
text = text.trim();
if( text.length() > 0 )
{
return text;
}
}
}
return defaultValue;
}
@SuppressWarnings( "unchecked" )
public static <T> T instantiate( final String pluginId,
final String clname,
final Class<T> interfc )
throws CoreException
{
final Bundle bundle = Platform.getBundle( pluginId );
final Object obj;
try
{
final Class cl = bundle.loadClass( clname );
obj = cl.newInstance();
}
catch( Exception e )
{
final String msg = NLS.bind( Resources.failedToCreate, clname );
throw new CoreException( createErrorStatus( -1, msg, e ) );
}
if( ! interfc.isAssignableFrom( obj.getClass() ) )
{
final String msg
= NLS.bind( Resources.doesNotImplement, clname, interfc.getClass().getName() );
throw new CoreException( createErrorStatus( -1, msg, null ) );
}
return (T) obj;
}
private static final class Resources
extends NLS
{
public static String missingAttribute;
public static String missingElement;
public static String failedToCreate;
public static String doesNotImplement;
static
{
initializeMessages( PluginUtil.class.getName(), Resources.class );
}
public static String bind( final String message,
final String arg1,
final String arg2,
final String arg3,
final String arg4 )
{
return bind( message, new Object[] { arg1, arg2, arg3, arg4 } );
}
}
}
}