tmf/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.tracecompass.internal.tmf.core.Activator;
  26 import org.eclipse.tracecompass.internal.tmf.core.analysis.TmfAnalysisModuleSourceConfigElement;
  27 import org.eclipse.tracecompass.tmf.core.exceptions.TmfAnalysisException;
  28 import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
  29 import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;
  30 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  31 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
  32 import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
  33 import org.osgi.framework.Bundle;
  34
  35 /**
  36  * Analysis module helper for modules provided by a plugin's configuration
  37  * elements.
  38  *
  39  * @author Geneviève Bastien
  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         String id = fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.ID_ATTR);
  62         if (id == null) {
  63             throw new IllegalStateException();
  64         }
  65         return id;
  66     }
  67
  68     @Override
  69     public String getName() {
  70         String name = fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR);
  71         if (name == null) {
  72             throw new IllegalStateException();
  73         }
  74         return name;
  75     }
  76
  77     @Override
  78     public boolean isAutomatic() {
  79         return Boolean.parseBoolean(fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.AUTOMATIC_ATTR));
  80     }
  81
  82     /**
  83      * @since 1.0
  84      */
  85     @Override
  86     public boolean appliesToExperiment() {
  87         return Boolean.parseBoolean(fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.APPLIES_EXP_ATTR));
  88     }
  89
  90     @Override
  91     public String getHelpText() {
  92         /*
  93          * FIXME: No need to externalize this. A better solution will be found
  94          * soon and this string is just temporary
  95          */
  96         return new String("The trace must be opened to get the help message"); //$NON-NLS-1$
  97     }
  98
  99     @Override
 100     public String getIcon() {
 101         return fCe.getAttribute(TmfAnalysisModuleSourceConfigElement.ICON_ATTR);
 102     }
 103
 104     @Override
 105     public Bundle getBundle() {
 106         return ContributorFactoryOSGi.resolve(fCe.getContributor());
 107     }
 108
 109     @Override
 110     public boolean appliesToTraceType(Class<? extends ITmfTrace> traceclass) {
 111         boolean applies = false;
 112
 113         /* Get the module's applying tracetypes */
 114         final IConfigurationElement[] tracetypeCE = fCe.getChildren(TmfAnalysisModuleSourceConfigElement.TRACETYPE_ELEM);
 115         for (IConfigurationElement element : tracetypeCE) {
 116             Class<?> applyclass;
 117             try {
 118                 applyclass = getBundle().loadClass(element.getAttribute(TmfAnalysisModuleSourceConfigElement.CLASS_ATTR));
 119                 String classAppliesVal = element.getAttribute(TmfAnalysisModuleSourceConfigElement.APPLIES_ATTR);
 120                 boolean classApplies = true;
 121                 if (classAppliesVal != null) {
 122                     classApplies = Boolean.parseBoolean(classAppliesVal);
 123                 }
 124                 if (classApplies) {
 125                     applies |= applyclass.isAssignableFrom(traceclass);
 126                 } else {
 127                     /*
 128                      * If the trace type does not apply, reset the applies
 129                      * variable to false
 130                      */
 131                     if (applyclass.isAssignableFrom(traceclass)) {
 132                         applies = false;
 133                     }
 134                 }
 135             } catch (ClassNotFoundException | InvalidRegistryObjectException e) {
 136                 Activator.logError("Error in applies to trace", e); //$NON-NLS-1$
 137             }
 138         }
 139         return applies;
 140     }
 141
 142     @Override
 143     public Iterable<Class<? extends ITmfTrace>> getValidTraceTypes() {
 144         Set<Class<? extends ITmfTrace>> traceTypes = new HashSet<>();
 145
 146         for (TraceTypeHelper tth : TmfTraceType.getTraceTypeHelpers()) {
 147             if (appliesToTraceType(tth.getTraceClass())) {
 148                 traceTypes.add(tth.getTraceClass());
 149             }
 150         }
 151
 152         return traceTypes;
 153     }
 154
 155     @Override
 156     public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
 157         IAnalysisModule module = createModule();
 158         if (module != null) {
 159             return module.getAnalysisRequirements();
 160         }
 161         return Collections.EMPTY_SET;
 162
 163     }
 164
 165     // ---------------------------------------
 166     // Functionalities
 167     // ---------------------------------------
 168
 169     private IAnalysisModule createModule() {
 170         IAnalysisModule module = null;
 171         try {
 172             module = (IAnalysisModule) fCe.createExecutableExtension(TmfAnalysisModuleSourceConfigElement.ANALYSIS_MODULE_ATTR);
 173             module.setName(getName());
 174             module.setId(getId());
 175         } catch (CoreException e) {
 176             Activator.logError("Error getting analysis modules from configuration files", e); //$NON-NLS-1$
 177         }
 178         return module;
 179     }
 180
 181     @Override
 182     public IAnalysisModule newModule(ITmfTrace trace) throws TmfAnalysisException {
 183
 184         /* Check if it applies to trace itself */
 185         boolean applies = appliesToTraceType(trace.getClass());
 186         /*
 187          * If the trace is an experiment, check if this module would apply to an
 188          * experiment should it apply to one of its traces.
 189          */
 190         if (!applies && (trace instanceof TmfExperiment) && appliesToExperiment()) {
 191             for (ITmfTrace expTrace : TmfTraceManager.getTraceSet(trace)) {
 192                 if (appliesToTraceType(expTrace.getClass())) {
 193                     applies = true;
 194                     break;
 195                 }
 196             }
 197         }
 198
 199         if (!applies) {
 200             return null;
 201         }
 202
 203         IAnalysisModule module = createModule();
 204         if (module == null) {
 205             return null;
 206         }
 207
 208         module.setAutomatic(isAutomatic());
 209
 210         /* Get the module's parameters */
 211         final IConfigurationElement[] parametersCE = fCe.getChildren(TmfAnalysisModuleSourceConfigElement.PARAMETER_ELEM);
 212         for (IConfigurationElement element : parametersCE) {
 213             String paramName = element.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR);
 214             if (paramName == null) {
 215                 continue;
 216             }
 217             module.addParameter(paramName);
 218             String defaultValue = element.getAttribute(TmfAnalysisModuleSourceConfigElement.DEFAULT_VALUE_ATTR);
 219             if (defaultValue != null) {
 220                 module.setParameter(paramName, defaultValue);
 221             }
 222         }
 223         if (module.setTrace(trace)) {
 224             TmfAnalysisManager.analysisModuleCreated(module);
 225         } else {
 226             module.dispose();
 227             module = null;
 228         }
 229
 230         return module;
 231
 232     }
 233
 234     @Override
 235     public String getHelpText(@NonNull ITmfTrace trace) {
 236         IAnalysisModule module = createModule();
 237         if (module != null) {
 238             String ret = module.getHelpText(trace);
 239             module.dispose();
 240             return ret;
 241         }
 242         return getHelpText();
 243
 244     }
 245 }