org.eclipse.tracecompass.tmf.core/src/org/eclipse/tracecompass/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.tracecompass.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.osgi.util.NLS;
  26 import org.eclipse.tracecompass.internal.tmf.core.Activator;
  27 import org.eclipse.tracecompass.internal.tmf.core.analysis.TmfAnalysisModuleSourceConfigElement;
  28 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
  29 import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
  30 import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;
  31 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  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  */
  40 public class TmfAnalysisModuleHelperConfigElement implements IAnalysisModuleHelper {
  41
  42     private final IConfigurationElement fCe;
  43
  44     /**
  45      * Constructor
  46      *
  47      * @param ce
  48      *            The source {@link IConfigurationElement} of this module helper
  49      */
  50     public TmfAnalysisModuleHelperConfigElement(IConfigurationElement ce) {
  51         fCe = ce;
  52     }
  53
  54     // ----------------------------------------
  55     // Wrappers to {@link IAnalysisModule} methods
  56     // ----------------------------------------
  57
  58     @Override
  59     public String getId() {
  60         String id = fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.ID_ATTR);
  61         if (id == null) {
  62             throw new IllegalStateException();
  63         }
  64         return id;
  65     }
  66
  67     @Override
  68     public String getName() {
  69         String name = fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR);
  70         if (name == null) {
  71             throw new IllegalStateException();
  72         }
  73         return name;
  74     }
  75
  76     @Override
  77     public boolean isAutomatic() {
  78         return Boolean.parseBoolean(fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.AUTOMATIC_ATTR));
  79     }
  80
  81     @Override
  82     public String getHelpText() {
  83         /*
  84          * FIXME: No need to externalize this. A better solution will be found
  85          * soon and this string is just temporary
  86          */
  87         return new String("The trace must be opened to get the help message"); //$NON-NLS-1$
  88     }
  89
  90     @Override
  91     public String getIcon() {
  92         return fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.ICON_ATTR);
  93     }
  94
  95     @Override
  96     public Bundle getBundle() {
  97         return ContributorFactoryOSGi.resolve(fCe.getContributor());
  98     }
  99
 100     @Override
 101     public boolean appliesToTraceType(Class<? extends ITmfTrace> traceclass) {
 102         boolean applies = false;
 103
 104         /* Get the module's applying tracetypes */
 105         final IConfigurationElement[] tracetypeCE = fCe.getChildren(TmfAnalysisModuleSourceConfigElement.TRACETYPE_ELEM);
 106         for (IConfigurationElement element : tracetypeCE) {
 107             Class<?> applyclass;
 108             try {
 109                 applyclass = getBundle().loadClass(element.getAttribute(TmfAnalysisModuleSourceConfigElement.CLASS_ATTR));
 110                 String classAppliesVal = element.getAttribute(TmfAnalysisModuleSourceConfigElement.APPLIES_ATTR);
 111                 boolean classApplies = true;
 112                 if (classAppliesVal != null) {
 113                     classApplies = Boolean.parseBoolean(classAppliesVal);
 114                 }
 115                 if (classApplies) {
 116                     applies |= applyclass.isAssignableFrom(traceclass);
 117                 } else {
 118                     /* If the trace type does not apply, reset the applies variable to false */
 119                     if (applyclass.isAssignableFrom(traceclass)) {
 120                         applies = false;
 121                     }
 122                 }
 123             } catch (ClassNotFoundException e) {
 124                 Activator.logError("Error in applies to trace", e); //$NON-NLS-1$
 125             } catch (InvalidRegistryObjectException e) {
 126                 Activator.logError("Error in applies to trace", e); //$NON-NLS-1$
 127             }
 128         }
 129         return applies;
 130     }
 131
 132     @Override
 133     public Iterable<Class<? extends ITmfTrace>> getValidTraceTypes() {
 134         Set<Class<? extends ITmfTrace>> traceTypes = new HashSet<>();
 135
 136         for (TraceTypeHelper tth : TmfTraceType.getTraceTypeHelpers()) {
 137             if (appliesToTraceType(tth.getTraceClass())) {
 138                 traceTypes.add(tth.getTraceClass());
 139             }
 140         }
 141
 142         return traceTypes;
 143     }
 144
 145     @Override
 146     public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
 147         IAnalysisModule module = createModule();
 148         if (module != null) {
 149             return module.getAnalysisRequirements();
 150         }
 151         return Collections.EMPTY_SET;
 152
 153     }
 154
 155     // ---------------------------------------
 156     // Functionalities
 157     // ---------------------------------------
 158
 159     private IAnalysisModule createModule() {
 160         IAnalysisModule module = null;
 161         try {
 162             module = (IAnalysisModule) fCe.createExecutableExtension(TmfAnalysisModuleSourceConfigElement.ANALYSIS_MODULE_ATTR);
 163             module.setName(getName());
 164             module.setId(getId());
 165         } catch (CoreException e) {
 166             Activator.logError("Error getting analysis modules from configuration files", e); //$NON-NLS-1$
 167         }
 168         return module;
 169     }
 170
 171     @Override
 172     public IAnalysisModule newModule(ITmfTrace trace) throws TmfAnalysisException {
 173
 174         /* Check that analysis can be executed */
 175         if (!appliesToTraceType(trace.getClass())) {
 176             throw new TmfAnalysisException(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, getName()));
 177         }
 178
 179         IAnalysisModule module = createModule();
 180         if (module == null) {
 181             return null;
 182         }
 183
 184         module.setAutomatic(isAutomatic());
 185
 186         /* Get the module's parameters */
 187         final IConfigurationElement[] parametersCE = fCe.getChildren(TmfAnalysisModuleSourceConfigElement.PARAMETER_ELEM);
 188         for (IConfigurationElement element : parametersCE) {
 189             String paramName = element.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR);
 190             if (paramName == null) {
 191                 continue;
 192             }
 193             module.addParameter(paramName);
 194             String defaultValue = element.getAttribute(TmfAnalysisModuleSourceConfigElement.DEFAULT_VALUE_ATTR);
 195             if (defaultValue != null) {
 196                 module.setParameter(paramName, defaultValue);
 197             }
 198         }
 199         module.setTrace(trace);
 200         TmfAnalysisManager.analysisModuleCreated(module);
 201
 202         return module;
 203
 204     }
 205
 206     @Override
 207     public String getHelpText(@NonNull ITmfTrace trace) {
 208         IAnalysisModule module = createModule();
 209         if (module != null) {
 210             String ret = module.getHelpText(trace);
 211             module.dispose();
 212             return ret;
 213         }
 214         return getHelpText();
 215
 216     }
 217 }