org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/analysis/TmfAnalysisModuleHelperConfigElement.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2014 École Polytechnique de Montréal
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Geneviève Bastien - Initial API and implementation
  11  *   Mathieu Rail - Added functionality for getting a module's requirements
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.core.analysis;
  15
  16 import java.util.Collections;
  17 import java.util.HashSet;
  18 import java.util.Set;
  19
  20 import org.eclipse.core.runtime.ContributorFactoryOSGi;
  21 import org.eclipse.core.runtime.CoreException;
  22 import org.eclipse.core.runtime.IConfigurationElement;
  23 import org.eclipse.core.runtime.InvalidRegistryObjectException;
  24 import org.eclipse.jdt.annotation.NonNull;
  25 import org.eclipse.linuxtools.internal.tmf.core.Activator;
  26 import org.eclipse.linuxtools.internal.tmf.core.analysis.TmfAnalysisModuleSourceConfigElement;
  27 import org.eclipse.linuxtools.tmf.core.exceptions.TmfAnalysisException;
  28 import org.eclipse.linuxtools.tmf.core.project.model.TmfTraceType;
  29 import org.eclipse.linuxtools.tmf.core.project.model.TraceTypeHelper;
  30 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  31 import org.eclipse.osgi.util.NLS;
  32 import org.osgi.framework.Bundle;
  33
  34 /**
  35  * Analysis module helper for modules provided by a plugin's configuration
  36  * elements.
  37  *
  38  * @author Geneviève Bastien
  39  * @since 3.0
  40  */
  41 public class TmfAnalysisModuleHelperConfigElement implements IAnalysisModuleHelper {
  42
  43     private final IConfigurationElement fCe;
  44
  45     /**
  46      * Constructor
  47      *
  48      * @param ce
  49      *            The source {@link IConfigurationElement} of this module helper
  50      */
  51     public TmfAnalysisModuleHelperConfigElement(IConfigurationElement ce) {
  52         fCe = ce;
  53     }
  54
  55     // ----------------------------------------
  56     // Wrappers to {@link IAnalysisModule} methods
  57     // ----------------------------------------
  58
  59     @Override
  60     public String getId() {
  61         return fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.ID_ATTR);
  62     }
  63
  64     @Override
  65     public String getName() {
  66         return fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR);
  67     }
  68
  69     @Override
  70     public boolean isAutomatic() {
  71         return Boolean.parseBoolean(fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.AUTOMATIC_ATTR));
  72     }
  73
  74     @Override
  75     public String getHelpText() {
  76         /*
  77          * FIXME: No need to externalize this. A better solution will be found
  78          * soon and this string is just temporary
  79          */
  80         return new String("The trace must be opened to get the help message"); //$NON-NLS-1$
  81     }
  82
  83     @Override
  84     public String getIcon() {
  85         return fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.ICON_ATTR);
  86     }
  87
  88     @Override
  89     public Bundle getBundle() {
  90         return ContributorFactoryOSGi.resolve(fCe.getContributor());
  91     }
  92
  93     @Override
  94     public boolean appliesToTraceType(Class<? extends ITmfTrace> traceclass) {
  95         boolean applies = false;
  96
  97         /* Get the module's applying tracetypes */
  98         final IConfigurationElement[] tracetypeCE = fCe.getChildren(TmfAnalysisModuleSourceConfigElement.TRACETYPE_ELEM);
  99         for (IConfigurationElement element : tracetypeCE) {
 100             Class<?> applyclass;
 101             try {
 102                 applyclass = getBundle().loadClass(element.getAttribute(TmfAnalysisModuleSourceConfigElement.CLASS_ATTR));
 103                 String classAppliesVal = element.getAttribute(TmfAnalysisModuleSourceConfigElement.APPLIES_ATTR);
 104                 boolean classApplies = true;
 105                 if (classAppliesVal != null) {
 106                     classApplies = Boolean.parseBoolean(classAppliesVal);
 107                 }
 108                 if (classApplies) {
 109                     applies |= applyclass.isAssignableFrom(traceclass);
 110                 } else {
 111                     /* If the trace type does not apply, reset the applies variable to false */
 112                     if (applyclass.isAssignableFrom(traceclass)) {
 113                         applies = false;
 114                     }
 115                 }
 116             } catch (ClassNotFoundException e) {
 117                 Activator.logError("Error in applies to trace", e); //$NON-NLS-1$
 118             } catch (InvalidRegistryObjectException e) {
 119                 Activator.logError("Error in applies to trace", e); //$NON-NLS-1$
 120             }
 121         }
 122         return applies;
 123     }
 124
 125     @Override
 126     public Iterable<Class<? extends ITmfTrace>> getValidTraceTypes() {
 127         Set<Class<? extends ITmfTrace>> traceTypes = new HashSet<>();
 128
 129         for (TraceTypeHelper tth : TmfTraceType.getTraceTypeHelpers()) {
 130             if (appliesToTraceType(tth.getTraceClass())) {
 131                 traceTypes.add(tth.getTraceClass());
 132             }
 133         }
 134
 135         return traceTypes;
 136     }
 137
 138     @Override
 139     public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
 140         IAnalysisModule module = createModule();
 141         if (module != null) {
 142             return module.getAnalysisRequirements();
 143         }
 144         return Collections.EMPTY_SET;
 145
 146     }
 147
 148     // ---------------------------------------
 149     // Functionalities
 150     // ---------------------------------------
 151
 152     private IAnalysisModule createModule() {
 153         IAnalysisModule module = null;
 154         try {
 155             module = (IAnalysisModule) fCe.createExecutableExtension(TmfAnalysisModuleSourceConfigElement.ANALYSIS_MODULE_ATTR);
 156             module.setName(getName());
 157             module.setId(getId());
 158         } catch (CoreException e) {
 159             Activator.logError("Error getting analysis modules from configuration files", e); //$NON-NLS-1$
 160         }
 161         return module;
 162     }
 163
 164     @Override
 165     public IAnalysisModule newModule(ITmfTrace trace) throws TmfAnalysisException {
 166
 167         /* Check that analysis can be executed */
 168         if (!appliesToTraceType(trace.getClass())) {
 169             throw new TmfAnalysisException(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, getName()));
 170         }
 171
 172         IAnalysisModule module = createModule();
 173         if (module == null) {
 174             return null;
 175         }
 176
 177         module.setAutomatic(isAutomatic());
 178
 179         /* Get the module's parameters */
 180         final IConfigurationElement[] parametersCE = fCe.getChildren(TmfAnalysisModuleSourceConfigElement.PARAMETER_ELEM);
 181         for (IConfigurationElement element : parametersCE) {
 182             module.addParameter(element.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR));
 183             String defaultValue = element.getAttribute(TmfAnalysisModuleSourceConfigElement.DEFAULT_VALUE_ATTR);
 184             if (defaultValue != null) {
 185                 module.setParameter(element.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR), defaultValue);
 186             }
 187         }
 188         module.setTrace(trace);
 189         TmfAnalysisManager.analysisModuleCreated(module);
 190
 191         return module;
 192
 193     }
 194
 195     @Override
 196     public String getHelpText(@NonNull ITmfTrace trace) {
 197         IAnalysisModule module = createModule();
 198         if (module != null) {
 199             String ret = module.getHelpText(trace);
 200             module.dispose();
 201             return ret;
 202         }
 203         return getHelpText();
 204
 205     }
 206 }