| /******************************************************************************* | |
| * Copyright (c) 2011 Mia-Software. | |
| * 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: | |
| * Fabien Giquel (Mia-Software) - initial API and implementation | |
| * Nicolas Bros (Mia-Software) - Bug 338702 - [Discovery] specify initial value for Parameters | |
| *******************************************************************************/ | |
| package org.eclipse.modisco.infra.discovery.core.internal; | |
| import java.lang.reflect.InvocationTargetException; | |
| import java.lang.reflect.Method; | |
| import java.util.Collection; | |
| import java.util.Collections; | |
| import java.util.HashSet; | |
| import java.util.Map; | |
| import java.util.Set; | |
| import org.eclipse.core.runtime.IProgressMonitor; | |
| import org.eclipse.core.runtime.NullProgressMonitor; | |
| import org.eclipse.gmt.modisco.infra.common.core.logging.MoDiscoLogger; | |
| import org.eclipse.jdt.core.dom.Modifier; | |
| import org.eclipse.modisco.infra.discovery.catalog.DirectionKind; | |
| import org.eclipse.modisco.infra.discovery.catalog.DiscovererDescription; | |
| import org.eclipse.modisco.infra.discovery.catalog.DiscovererParameter; | |
| import org.eclipse.modisco.infra.discovery.core.IDiscoverer; | |
| import org.eclipse.modisco.infra.discovery.core.IDiscoveryManager; | |
| import org.eclipse.modisco.infra.discovery.core.exception.DiscoveryException; | |
| import org.eclipse.modisco.infra.discovery.core.internal.catalog.DiscovererRegistry; | |
| /** | |
| * Registry for accessing {@link IDiscoverer} instances. | |
| * | |
| */ | |
| public final class DiscoveryManager implements IDiscoveryManager { | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * getDiscoverer(java.lang.String) | |
| */ | |
| public IDiscoverer<?> createDiscovererImpl(final String id) { | |
| DiscovererDescription discovererDescription = getDiscovererDescription(id); | |
| if (discovererDescription != null) { | |
| return createDiscovererImpl(discovererDescription); | |
| } | |
| return null; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * getDiscoverer | |
| * (org.eclipse.modisco.infra.discovery.catalog.DiscovererDescription) | |
| */ | |
| public IDiscoverer<?> createDiscovererImpl(final DiscovererDescription description) { | |
| return DiscovererRegistry.INSTANCE.createDiscoverer(description); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * getApplicableDiscoverers(java.lang.Object) | |
| */ | |
| public Collection<DiscovererDescription> getApplicableDiscoverers(final Object source) { | |
| Set<DiscovererDescription> result = new HashSet<DiscovererDescription>(); | |
| for (DiscovererDescription aDiscoveryHandler : getDiscoverers()) { | |
| if (isApplicable(aDiscoveryHandler, source)) { | |
| result.add(aDiscoveryHandler); | |
| } | |
| } | |
| return Collections.unmodifiableSet(result); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * isApplicable | |
| * (org.eclipse.modisco.infra.discovery.catalog.DiscovererDescription, | |
| * java.lang.Object) | |
| */ | |
| @SuppressWarnings("unchecked") | |
| public boolean isApplicable(final DiscovererDescription discovererDefinition, | |
| final Object source) { | |
| // We must check the parameterized source type (T) of delegate | |
| // before calling isApplicableTo to avoid ClassCastException (case of | |
| // wildcard declarations) | |
| Class<?> discovererSourceType = discovererDefinition.getSourceType(); | |
| // used a cached discoverer to avoid having to create a new instance | |
| // each time this method is called | |
| IDiscoverer<?> cachedDiscoverer = DiscovererRegistry.INSTANCE | |
| .getCachedDiscoverer(discovererDefinition); | |
| return discovererSourceType != null && discovererSourceType.isInstance(source) | |
| && ((IDiscoverer<Object>) cachedDiscoverer).isApplicableTo(source); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * getDiscoverers() | |
| */ | |
| public Collection<DiscovererDescription> getDiscoverers() { | |
| return DiscovererRegistry.INSTANCE.getDiscovererDescriptions(); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * getDiscovererDescription(java.lang.Class) | |
| */ | |
| public static DiscovererDescription getDiscovererDescription(final Class<?> discovererClass) { | |
| Collection<DiscovererDescription> discovererDescriptions = DiscovererRegistry.INSTANCE | |
| .getDiscovererDescriptions(); | |
| for (DiscovererDescription discovererDescription : discovererDescriptions) { | |
| if (discovererClass.equals(discovererDescription.getImplementationType())) { | |
| return discovererDescription; | |
| } | |
| } | |
| return null; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * getDiscovererDescription(java.lang.String) | |
| */ | |
| public DiscovererDescription getDiscovererDescription(final String id) { | |
| for (DiscovererDescription discovererDescription : getDiscoverers()) { | |
| if (id.equals(discovererDescription.getId())) { | |
| return discovererDescription; | |
| } | |
| } | |
| return null; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * getDiscovererDescription | |
| * (org.eclipse.modisco.infra.discovery.core.IDiscoverer) | |
| */ | |
| public DiscovererDescription getDiscovererDescription(final IDiscoverer<?> discoverer) { | |
| for (DiscovererDescription discovererDescription : getDiscoverers()) { | |
| if (discovererDescription.getImplementationType().equals(discoverer.getClass())) { | |
| return discovererDescription; | |
| } | |
| // IDiscoverer<?> cachedDiscoverer = DiscovererRegistry.INSTANCE | |
| // .getCachedDiscoverer(discovererDescription); | |
| // if (cachedDiscoverer.getClass().equals(discoverer.getClass())) { | |
| // return discovererDescription; | |
| // } | |
| } | |
| return null; | |
| } | |
| /** | |
| * This method computes at runtime the source type argument for one | |
| * discoverer implementation (generic T type) | |
| */ | |
| protected static void computeSourceType(final DiscovererDescription discovererDescription) { | |
| Class<?> sourceType = null; | |
| try { | |
| // At runtime we look for the "isApplicableTo(T)" method to deduce | |
| // the instantiated T type | |
| for (Method aMethod : discovererDescription.getImplementationType().getMethods()) { | |
| if (aMethod.getName().equals("isApplicableTo") //$NON-NLS-1$ | |
| && aMethod.getParameterTypes().length == 1) { | |
| Class<?> parameterClass = aMethod.getParameterTypes()[0]; | |
| if (sourceType == null || parameterClass != java.lang.Object.class) { | |
| sourceType = parameterClass; | |
| } | |
| } | |
| } | |
| } catch (IllegalArgumentException e) { | |
| MoDiscoLogger.logWarning(e, Activator.getDefault()); | |
| } | |
| discovererDescription.setSourceType(sourceType); | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * canRetrieveValue | |
| * (org.eclipse.modisco.infra.discovery.catalog.DiscovererParameter) | |
| */ | |
| public boolean canRetrieveValue(final DiscovererParameter parameter) { | |
| boolean result = parameter.getField() != null | |
| && Modifier.isPublic(parameter.getField().getModifiers()); | |
| result = result | |
| || (parameter.getGetter() != null && Modifier.isPublic(parameter.getGetter() | |
| .getModifiers())); | |
| return result; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager#getValue | |
| * (org.eclipse.modisco.infra.discovery.catalog.DiscovererParameter, | |
| * org.eclipse.modisco.infra.discovery.core.IDiscoverer) | |
| */ | |
| public Object getValue(final DiscovererParameter parameter, final IDiscoverer<?> discoverer) | |
| throws DiscoveryException { | |
| Object parameterValue = null; | |
| try { | |
| if (parameter.getField() != null | |
| && Modifier.isPublic(parameter.getField().getModifiers())) { | |
| parameterValue = parameter.getField().get(discoverer); | |
| } else if (parameter.getGetter() != null | |
| && Modifier.isPublic(parameter.getGetter().getModifiers())) { | |
| parameterValue = parameter.getGetter().invoke(discoverer); | |
| } else { | |
| throw new DiscoveryException(discoverer.getClass() | |
| + " discoverer does not implement public read access to the parameter " //$NON-NLS-1$ | |
| + parameter.getId()); | |
| } | |
| } catch (IllegalArgumentException e) { | |
| throw new DiscoveryException("Illegal parameter value for " //$NON-NLS-1$ | |
| + parameter.getId(), e); | |
| } catch (IllegalAccessException e) { | |
| throw new DiscoveryException("Illegal parameter value for " //$NON-NLS-1$ | |
| + parameter.getId(), e); | |
| } catch (InvocationTargetException e) { | |
| throw new DiscoveryException("Illegal parameter value for " //$NON-NLS-1$ | |
| + parameter.getId(), e); | |
| } | |
| return parameterValue; | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see | |
| * org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager#setValue | |
| * (org.eclipse.modisco.infra.discovery.catalog.DiscovererParameter, | |
| * org.eclipse.modisco.infra.discovery.core.IDiscoverer, java.lang.Object) | |
| */ | |
| public void setValue(final DiscovererParameter parameter, final IDiscoverer<?> discoverer, | |
| final Object parameterValue) throws DiscoveryException { | |
| try { | |
| if (parameter.getField() != null | |
| && Modifier.isPublic(parameter.getField().getModifiers())) { | |
| parameter.getField().set(discoverer, parameterValue); | |
| } else if (parameter.getSetter() != null | |
| && Modifier.isPublic(parameter.getSetter().getModifiers())) { | |
| parameter.getSetter().invoke(discoverer, parameterValue); | |
| } else { | |
| throw new DiscoveryException(discoverer.getClass() | |
| + " discoverer does not implement public write access to the parameter " //$NON-NLS-1$ | |
| + parameter.getId()); | |
| } | |
| } catch (IllegalArgumentException e) { | |
| throw new DiscoveryException("Illegal parameter value for " //$NON-NLS-1$ | |
| + parameter.getId() + " : " + parameterValue, e); //$NON-NLS-1$ | |
| } catch (IllegalAccessException e) { | |
| throw new DiscoveryException("Illegal parameter value for " //$NON-NLS-1$ | |
| + parameter.getId() + " : " + parameterValue, e); //$NON-NLS-1$ | |
| } catch (InvocationTargetException e) { | |
| throw new DiscoveryException("Illegal parameter value for " //$NON-NLS-1$ | |
| + parameter.getId() + " : " + parameterValue, e); //$NON-NLS-1$ | |
| } | |
| } | |
| /* | |
| * (non-Javadoc) | |
| * | |
| * @see org.eclipse.modisco.infra.discovery.core.catalog.IDiscoveryManager# | |
| * discoverElement(org.eclipse.modisco.infra.discovery.core.IDiscoverer, | |
| * java.lang.Object, java.util.Map) | |
| */ | |
| @SuppressWarnings("unchecked") | |
| public void discoverElement(final IDiscoverer<?> discoverer, final Object source, | |
| final Map<String, Object> parametersValues, final IProgressMonitor monitor) | |
| throws DiscoveryException { | |
| DiscovererDescription discoDesc = getDiscovererDescription(discoverer); | |
| // affect parameters input values | |
| for (Map.Entry<String, Object> entry : parametersValues.entrySet()) { | |
| DiscovererParameter parameter = discoDesc.getParameterDefinition(entry.getKey()); | |
| if (parameter == null) { | |
| throw new DiscoveryException("Illegal parameter name : " + entry.getKey() //$NON-NLS-1$ | |
| + " for discoverer : " + discoDesc.getId()); //$NON-NLS-1$ | |
| } | |
| setValue(parameter, discoverer, entry.getValue()); | |
| } | |
| final IProgressMonitor progressMonitor; | |
| if (monitor != null) { | |
| progressMonitor = monitor; | |
| } else { | |
| progressMonitor = new NullProgressMonitor(); | |
| } | |
| // launch discovery | |
| ((IDiscoverer<Object>) discoverer).discoverElement(source, progressMonitor); | |
| // give output values | |
| for (DiscovererParameter parameter : discoDesc.getParameterDefinitions()) { | |
| if (parameter.getDirection().equals(DirectionKind.OUT) | |
| || parameter.getDirection().equals(DirectionKind.INOUT)) { | |
| parametersValues.put(parameter.getId(), getValue(parameter, discoverer)); | |
| } | |
| } | |
| } | |
| public boolean hasInitialValue(final DiscovererParameter parameter, | |
| final DiscovererDescription discoverer) { | |
| return parameter.getInitializer() != null | |
| && Modifier.isPublic(parameter.getInitializer().getModifiers()); | |
| } | |
| public Object getInitialValue(final DiscovererParameter parameter, | |
| final DiscovererDescription discoverer, final Object source) throws DiscoveryException { | |
| Object parameterValue = null; | |
| try { | |
| if (parameter.getInitializer() != null) { | |
| if (Modifier.isPublic(parameter.getInitializer().getModifiers())) { | |
| IDiscoverer<?> cachedDiscoverer = DiscovererRegistry.INSTANCE | |
| .getCachedDiscoverer(discoverer); | |
| parameterValue = parameter.getInitializer().invoke(cachedDiscoverer, source); | |
| } else { | |
| throw new DiscoveryException( | |
| discoverer.getClass() | |
| + " discoverer does not implement public read access to the parameter initializer " //$NON-NLS-1$ | |
| + parameter.getId()); | |
| } | |
| } else { | |
| return null; | |
| } | |
| } catch (IllegalArgumentException e) { | |
| throw new DiscoveryException("Illegal parameter initializer for " //$NON-NLS-1$ | |
| + parameter.getId(), e); | |
| } catch (IllegalAccessException e) { | |
| throw new DiscoveryException("Illegal parameter initializer for " //$NON-NLS-1$ | |
| + parameter.getId(), e); | |
| } catch (InvocationTargetException e) { | |
| throw new DiscoveryException("Illegal parameter initializer for " //$NON-NLS-1$ | |
| + parameter.getId(), e); | |
| } | |
| return parameterValue; | |
| } | |
| } |