← Back to branch summary

~ubuntu-branches/ubuntu/vivid/eclipse-linuxtools/vivid-proposed

« back to all changes in this revision

Viewing changes to lttng/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/analysis/TmfAnalysisModuleHelperConfigElement.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam, Jakub Adam, tony mancill
  • Date: 2014-10-11 11:44:05 UTC
  • mfrom: (1.2.4)
  • Revision ID: package-import@ubuntu.com-20141011114405-yazjvxfzzhmi5sgj
Tags: 3.1.0-1
http://bugs.debian.org/761524
[ Jakub Adam ]
* New upstream release (Closes: #761524).
* Refreshed d/patches.
* Don't build removed feature org.eclipse.linuxtools.tools.launch
  - merged into org.eclipse.linuxtools.profiling.
* Use javac target 1.7.
* Build new feature org.eclipse.linuxtools.dataviewers.feature
  - required by Valgrind integration.
* Build-depend on eclipse-remote-services-api and eclipse-cdt-autotools.
* Bump Standards-Version to 3.9.6.
* Override incompatible-java-bytecode-format - linuxtools needs Java 7.
* Remove unused codeless-jar override.

[ tony mancill ]
* Tweak short package description to make lintian happy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lttng/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
}