import java.util.List;
import org.eclipse.core.runtime.Path;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.linuxtools.internal.tmf.analysis.xml.ui.Activator;
import org.eclipse.linuxtools.tmf.analysis.xml.core.module.XmlUtils;
import org.eclipse.linuxtools.tmf.analysis.xml.core.stateprovider.TmfXmlStrings;
return new String();
}
+ @Override
+ public String getHelpText(@NonNull ITmfTrace trace) {
+ return ""; //$NON-NLS-1$
+ }
+
@Override
public String getIcon() {
return null;
import java.util.Collections;
import org.eclipse.core.runtime.Platform;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.linuxtools.tmf.core.analysis.IAnalysisModule;
import org.eclipse.linuxtools.tmf.core.analysis.IAnalysisModuleHelper;
import org.eclipse.linuxtools.tmf.core.analysis.TmfAnalysisRequirement;
return "";
}
+ @Override
+ public String getHelpText(@NonNull ITmfTrace trace) {
+ return "";
+ }
+
@Override
public String getIcon() {
return "";
package org.eclipse.linuxtools.tmf.core.analysis;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.osgi.framework.Bundle;
*/
String getHelpText();
+ /**
+ * Gets a specific help message/documentation for this analysis module
+ * applied on the given trace. This help message can add information on the
+ * status of this analysis for a given trace, whether it can be executed or
+ * not and why.
+ *
+ * This help text will be displayed to the user and may contain information
+ * on what the module does, how to use it and how to correctly generate the
+ * trace to make it available
+ *
+ * @param trace
+ * A trace for which to get specific help message
+ * @return The generic help text
+ */
+ String getHelpText(@NonNull ITmfTrace trace);
+
/**
* Gets the icon for this module
*
* helper and initializes it with the trace.
*
* After the module is fully created, this method should call
- * {@link TmfAnalysisManager#analysisModuleCreated(IAnalysisModule)} in order
- * for the new module listeners to be executed on this module.
+ * {@link TmfAnalysisManager#analysisModuleCreated(IAnalysisModule)} in
+ * order for the new module listeners to be executed on this module.
*
* @param trace
* The trace to be linked to the module
/** The trace to set was null */
public static String TmfAbstractAnalysisModule_NullTrace;
+ /** Additional information on a requirement */
+ public static String TmfAnalysis_RequirementInformation;
+
+ /** Mandatory values of a requirement */
+ public static String TmfAnalysis_RequirementMandatoryValues;
+
+ /** A requirement is not fulfilled */
+ public static String TmfAnalysis_RequirementNotFulfilled;
+
/** Running analysis */
public static String TmfAbstractAnalysisModule_RunningAnalysis;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.linuxtools.internal.tmf.core.Activator;
+import org.eclipse.linuxtools.tmf.core.analysis.TmfAnalysisRequirement.ValuePriorityLevel;
import org.eclipse.linuxtools.tmf.core.component.TmfComponent;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfAnalysisException;
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
/**
* Gets the help text specific for a trace who does not have required
- * characteristics for module to execute
+ * characteristics for module to execute. The default implementation uses
+ * the analysis requirements.
*
* @param trace
* The trace to apply the analysis to
* @return Help text
*/
- protected String getTraceCannotExecuteHelpText(ITmfTrace trace) {
- return Messages.TmfAbstractAnalysisModule_AnalysisCannotExecute;
+ protected String getTraceCannotExecuteHelpText(@NonNull ITmfTrace trace) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(NLS.bind(Messages.TmfAbstractAnalysisModule_AnalysisCannotExecute, getName()));
+ for (TmfAnalysisRequirement requirement : getAnalysisRequirements()) {
+ if (!requirement.isFulfilled(trace)) {
+ builder.append("\n\n"); //$NON-NLS-1$
+ builder.append(NLS.bind(Messages.TmfAnalysis_RequirementNotFulfilled, requirement.getType()));
+ builder.append("\n"); //$NON-NLS-1$
+ builder.append(NLS.bind(Messages.TmfAnalysis_RequirementMandatoryValues, requirement.getValues(ValuePriorityLevel.MANDATORY)));
+ Set<String> information = requirement.getInformation();
+ if (!information.isEmpty()) {
+ builder.append("\n"); //$NON-NLS-1$
+ builder.append(NLS.bind(Messages.TmfAnalysis_RequirementInformation, information));
+ }
+ }
+ }
+ return builder.toString();
}
@Override
}
String text = getShortHelpText(trace);
if (!canExecute(trace)) {
- text = text + getTraceCannotExecuteHelpText(trace);
+ text = text + "\n\n" + getTraceCannotExecuteHelpText(trace); //$NON-NLS-1$
}
return text;
}
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.linuxtools.internal.tmf.core.Activator;
import org.eclipse.linuxtools.internal.tmf.core.analysis.TmfAnalysisModuleSourceConfigElement;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfAnalysisException;
@Override
public Iterable<TmfAnalysisRequirement> getAnalysisRequirements() {
- /**
- * TODO: This method returns only the requirement of the first
- * applicable tracetype. We may assume that requirements will be the
- * same no matter the trace type, the trace generator will know how to
- * handle those. But this will have to be confirmed when the situation
- * happens.
- */
- for (TraceTypeHelper helper : TmfTraceType.getInstance().getTraceTypeHelpers()) {
- if (appliesToTraceType(helper.getTraceClass())) {
- try {
- return newModule(helper.getTrace()).getAnalysisRequirements();
- } catch (TmfAnalysisException e) {
- Activator.logError("Error in get analysis requirements", e); //$NON-NLS-1$
- }
- }
+ IAnalysisModule module = createModule();
+ if (module != null) {
+ return module.getAnalysisRequirements();
}
-
return Collections.EMPTY_SET;
}
// Functionalities
// ---------------------------------------
+ private IAnalysisModule createModule() {
+ IAnalysisModule module = null;
+ try {
+ module = (IAnalysisModule) fCe.createExecutableExtension(TmfAnalysisModuleSourceConfigElement.ANALYSIS_MODULE_ATTR);
+ module.setName(getName());
+ module.setId(getId());
+ } catch (CoreException e) {
+ Activator.logError("Error getting analysis modules from configuration files", e); //$NON-NLS-1$
+ }
+ return module;
+ }
+
@Override
public IAnalysisModule newModule(ITmfTrace trace) throws TmfAnalysisException {
throw new TmfAnalysisException(NLS.bind(Messages.TmfAnalysisModuleHelper_AnalysisDoesNotApply, getName()));
}
- IAnalysisModule module = null;
- try {
- module = (IAnalysisModule) fCe.createExecutableExtension(TmfAnalysisModuleSourceConfigElement.ANALYSIS_MODULE_ATTR);
- module.setName(getName());
- module.setId(getId());
- module.setAutomatic(isAutomatic());
-
- /* Get the module's parameters */
- final IConfigurationElement[] parametersCE = fCe.getChildren(TmfAnalysisModuleSourceConfigElement.PARAMETER_ELEM);
- for (IConfigurationElement element : parametersCE) {
- module.addParameter(element.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR));
- String defaultValue = element.getAttribute(TmfAnalysisModuleSourceConfigElement.DEFAULT_VALUE_ATTR);
- if (defaultValue != null) {
- module.setParameter(element.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR), defaultValue);
- }
+ IAnalysisModule module = createModule();
+ if (module == null) {
+ return null;
+ }
+
+ module.setAutomatic(isAutomatic());
+
+ /* Get the module's parameters */
+ final IConfigurationElement[] parametersCE = fCe.getChildren(TmfAnalysisModuleSourceConfigElement.PARAMETER_ELEM);
+ for (IConfigurationElement element : parametersCE) {
+ module.addParameter(element.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR));
+ String defaultValue = element.getAttribute(TmfAnalysisModuleSourceConfigElement.DEFAULT_VALUE_ATTR);
+ if (defaultValue != null) {
+ module.setParameter(element.getAttribute(TmfAnalysisModuleSourceConfigElement.NAME_ATTR), defaultValue);
}
- module.setTrace(trace);
- TmfAnalysisManager.analysisModuleCreated(module);
- } catch (CoreException e) {
- Activator.logError("Error getting analysis modules from configuration files", e); //$NON-NLS-1$
}
+ module.setTrace(trace);
+ TmfAnalysisManager.analysisModuleCreated(module);
+
return module;
}
+
+ @Override
+ public String getHelpText(@NonNull ITmfTrace trace) {
+ IAnalysisModule module = createModule();
+ if (module != null) {
+ String ret = module.getHelpText(trace);
+ module.dispose();
+ return ret;
+ }
+ return getHelpText();
+ }
}
TmfAbstractAnalysisModule_AnalysisModule=Analysis module: {0}
TmfAbstractAnalysisModule_InvalidParameter=Parameter {0} is not valid for analysis module {1}
TmfAbstractAnalysisModule_NullTrace=Setting a null trace to analysis module
+TmfAnalysis_RequirementInformation=Additional information: {0}
+TmfAnalysis_RequirementMandatoryValues=Mandatory values: {0}
+TmfAnalysis_RequirementNotFulfilled=Requirement not fulfilled: {0}
TmfAbstractAnalysisModule_RunningAnalysis=Running analysis {0}
TmfAnalysisManager_ErrorParameterProvider=Error instantiating parameter provider
TmfAnalysisModuleHelper_ImpossibleToCreateModule=Could not instantiate module "{0}"
return new String();
}
+ if (trace != null) {
+ return helper.getHelpText(trace);
+ }
+
return helper.getHelpText();
}
projects / deliverable / tracecompass.git / commitdiff
