This avoids NPE when Traces or Experiment folder have been deleted.
Handle gracefully the case when these folders don't exist on disk.
Change-Id: I5be56609be138dc22f6917e5da2a9638d140fb0c
Signed-off-by: Bernd Hufmann <Bernd.Hufmann@ericsson.com>
Reviewed-on: https://git.eclipse.org/r/89142
Reviewed-by: Hudson CI
Reviewed-by: Jean-Christian Kouame <jean-christian.kouame@ericsson.com>
Tested-by: Jean-Christian Kouame <jean-christian.kouame@ericsson.com>
private static void verifyExperimentFolder(boolean createExperiment, TmfProjectElement tmfProject, String experimentName) {
TmfExperimentFolder expFolder = tmfProject.getExperimentsFolder();
+ assertNotNull(expFolder);
if (createExperiment) {
if (experimentName != null) {
TmfExperimentElement expElement = expFolder.getExperiment(experimentName);
TmfTraceTypeUIUtils.setTraceType(traceFolder, selectedTraceType);
final TmfProjectElement projectElement = TmfProjectRegistry.getProject(project, true);
- final TmfTraceFolder tracesFolder = projectElement.getTracesFolder();
- final List<TmfTraceElement> traces = tracesFolder.getTraces();
TmfTraceElement found = null;
- for (TmfTraceElement candidate : traces) {
- if (candidate.getName().equals(connectionInfo.getSessionName())) {
- found = candidate;
+ final TmfTraceFolder tracesFolder = projectElement.getTracesFolder();
+ if (tracesFolder != null) {
+ final List<TmfTraceElement> traces = tracesFolder.getTraces();
+ for (TmfTraceElement candidate : traces) {
+ if (candidate.getName().equals(connectionInfo.getSessionName())) {
+ found = candidate;
+ }
}
}
import org.eclipse.tracecompass.internal.tmf.analysis.xml.ui.Activator;
import org.eclipse.tracecompass.tmf.ui.dialog.TmfFileDialogFactory;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfCommonProjectElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectModelElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TraceUtils;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IPropertyListener;
TmfProjectElement pElement = TmfProjectRegistry.getProject(project);
if (pElement != null) {
java.util.List<TmfCommonProjectElement> tElements = new ArrayList<>();
- tElements.addAll(pElement.getTracesFolder().getTraces());
- tElements.addAll(pElement.getExperimentsFolder().getExperiments());
+ TmfTraceFolder tracesFolder = pElement.getTracesFolder();
+ if (tracesFolder != null) {
+ tElements.addAll(tracesFolder.getTraces());
+ }
+ TmfExperimentFolder experimentsFolder = pElement.getExperimentsFolder();
+ if (experimentsFolder != null) {
+ tElements.addAll(experimentsFolder.getExperiments());
+ }
for (TmfCommonProjectElement tElement : tElements) {
boolean closeEditor = false;
for (IResource resource : tElement.getSupplementaryResources()) {
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitUtils;
@Override
public boolean test() throws Exception {
- return fProject.getTracesFolder().getTraces().size() == fExpectedCount;
+ final TmfTraceFolder tracesFolder = fProject.getTracesFolder();
+ return ((tracesFolder != null) && (tracesFolder.getTraces().size() == fExpectedCount));
}
@Override
public void run() {
final TmfProjectElement project = TmfProjectRegistry.getProject(ResourcesPlugin.getWorkspace().getRoot().getProject(PROJECT_NAME), true);
fBot.waitUntil(new TraceCountCondition(project, 2));
- List<TmfTraceElement> traces = project.getTracesFolder().getTraces();
+ final TmfTraceFolder tracesFolder = project.getTracesFolder();
+ assertNotNull(tracesFolder);
+ List<TmfTraceElement> traces = tracesFolder.getTraces();
assertEquals(2, traces.size());
testTrace(traces.get(0), CONNECTION_NODE_NAME + "/resources/generated/synthetic-trace", TRACE_TYPE_LTTNG);
testTrace(traces.get(1), CONNECTION_NODE_NAME + "/resources/syslog", TRACE_TYPE_SYSLOG);
public void run() {
TmfProjectElement project = TmfProjectRegistry.getProject(ResourcesPlugin.getWorkspace().getRoot().getProject(PROJECT_NAME), true);
fBot.waitUntil(new TraceCountCondition(project, 1));
- List<TmfTraceElement> traces = project.getTracesFolder().getTraces();
+ final TmfTraceFolder tracesFolder = project.getTracesFolder();
+ assertNotNull(tracesFolder);
+ List<TmfTraceElement> traces = tracesFolder.getTraces();
assertEquals(1, traces.size());
testTrace(traces.get(0), CONNECTION_NODE_NAME + "/resources/syslog", TRACE_TYPE_SYSLOG);
}
@Override
public void run() {
TmfProjectElement project = TmfProjectRegistry.getProject(ResourcesPlugin.getWorkspace().getRoot().getProject(PROJECT_NAME), true);
- List<TmfTraceElement> traces = project.getTracesFolder().getTraces();
+ final TmfTraceFolder tracesFolder = project.getTracesFolder();
+ assertNotNull(tracesFolder);
+ List<TmfTraceElement> traces = tracesFolder.getTraces();
assertEquals(0, traces.size());
}
});
@Override
public void run() {
TmfProjectElement project = TmfProjectRegistry.getProject(ResourcesPlugin.getWorkspace().getRoot().getProject(PROJECT_NAME), true);
- List<TmfTraceElement> traces = project.getTracesFolder().getTraces();
+ final TmfTraceFolder tracesFolder = project.getTracesFolder();
+ assertNotNull(tracesFolder);
+ List<TmfTraceElement> traces = tracesFolder.getTraces();
assertEquals(0, traces.size());
}
});
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
TmfProjectElement tmfProject = TmfProjectRegistry.getProject(project, false);
TmfTraceFolder tracesFolder = tmfProject.getTracesFolder();
+ if (tracesFolder == null) {
+ return;
+ }
try {
for (TmfTraceElement traceElement : tracesFolder.getTraces()) {
traceElement.delete(null);
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
TmfProjectElement tmfProject = TmfProjectRegistry.getProject(project, false);
TmfExperimentFolder expFolder = tmfProject.getExperimentsFolder();
+ if (expFolder == null) {
+ return;
+ }
expFolder.getExperiments().forEach(experiment -> {
IResource resource = experiment.getResource();
try {
import org.eclipse.tracecompass.tmf.ui.project.model.ITmfProjectModelElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfCommonProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTracesFolder;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
"org.eclipse.linuxtools.tmf.core.tests.tracetype");
final TmfProjectElement projectElement = TmfProjectRegistry.getProject(project, true);
- TmfTraceElement traceElement = projectElement.getTracesFolder().getTraces().get(0);
- traceElement.refreshTraceType();
+ TmfTraceFolder tracesFolder = projectElement.getTracesFolder(); {
+ if (tracesFolder != null) {
+ TmfTraceElement traceElement = tracesFolder.getTraces().get(0);
+ traceElement.refreshTraceType();
+ }
+ }
projectElement.refresh();
* @return The newly created experiment
*/
public static TmfExperimentElement addExperiment(TmfProjectElement projectElement, String experimentName) {
- IFolder experimentFolder = projectElement.getExperimentsFolder().getResource();
- final IFolder folder = experimentFolder.getFolder(experimentName);
+ TmfExperimentFolder experimentsFolder = projectElement.getExperimentsFolder();
+ if (experimentsFolder != null) {
+ IFolder experimentFolder = experimentsFolder.getResource();
+ final IFolder folder = experimentFolder.getFolder(experimentName);
- WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
- @Override
- public void execute(IProgressMonitor monitor) throws CoreException {
- monitor.beginTask("", 1000);
- folder.create(false, true, monitor);
- monitor.done();
- }
- };
- try {
- PlatformUI.getWorkbench().getProgressService().busyCursorWhile(operation);
- } catch (InterruptedException | InvocationTargetException | RuntimeException exception) {
-
- }
+ WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
+ @Override
+ public void execute(IProgressMonitor monitor) throws CoreException {
+ monitor.beginTask("", 1000);
+ folder.create(false, true, monitor);
+ monitor.done();
+ }
+ };
+ try {
+ PlatformUI.getWorkbench().getProgressService().busyCursorWhile(operation);
+ } catch (InterruptedException | InvocationTargetException | RuntimeException exception) {
- for (ITmfProjectModelElement el : projectElement.getExperimentsFolder().getChildren()) {
- if (el.getName().equals(experimentName) && (el instanceof TmfExperimentElement)) {
- return (TmfExperimentElement) el;
+ }
+ for (ITmfProjectModelElement el : experimentsFolder.getChildren()) {
+ if (el.getName().equals(experimentName) && (el instanceof TmfExperimentElement)) {
+ return (TmfExperimentElement) el;
+ }
}
}
return null;
*/
public static void deleteProject(TmfProjectElement project) {
/* Delete experiments */
- ITmfProjectModelElement[] experiments = project.getExperimentsFolder().getChildren().toArray(new ITmfProjectModelElement[0]);
- for (ITmfProjectModelElement element : experiments) {
- if (element instanceof TmfExperimentElement) {
- TmfExperimentElement experiment = (TmfExperimentElement) element;
- IResource resource = experiment.getResource();
+ TmfExperimentFolder experimentsFolder = project.getExperimentsFolder();
+ if (experimentsFolder != null) {
+ ITmfProjectModelElement[] experiments = experimentsFolder.getChildren().toArray(new ITmfProjectModelElement[0]);
+ for (ITmfProjectModelElement element : experiments) {
+ if (element instanceof TmfExperimentElement) {
+ TmfExperimentElement experiment = (TmfExperimentElement) element;
+ IResource resource = experiment.getResource();
- /* Close the experiment if open */
- experiment.closeEditors();
+ /* Close the experiment if open */
+ experiment.closeEditors();
- IPath path = resource.getLocation();
- if (path != null) {
- /* Delete supplementary files */
- experiment.deleteSupplementaryFolder();
- }
+ IPath path = resource.getLocation();
+ if (path != null) {
+ /* Delete supplementary files */
+ experiment.deleteSupplementaryFolder();
+ }
- /* Finally, delete the experiment */
- try {
- resource.delete(true, null);
- } catch (CoreException e) {
- Activator.getDefault().logError("Error deleting experiment element", e);
+ /* Finally, delete the experiment */
+ try {
+ resource.delete(true, null);
+ } catch (CoreException e) {
+ Activator.getDefault().logError("Error deleting experiment element", e);
+ }
}
}
}
/* Delete traces */
- ITmfProjectModelElement[] traces = project.getTracesFolder().getChildren().toArray(new ITmfProjectModelElement[0]);
- for (ITmfProjectModelElement element : traces) {
- if (element instanceof TmfTraceElement) {
- TmfTraceElement trace = (TmfTraceElement) element;
- IResource resource = trace.getResource();
+ TmfTraceFolder tracesFolder = project.getTracesFolder();
+ if (tracesFolder != null) {
+ ITmfProjectModelElement[] traces = tracesFolder.getChildren().toArray(new ITmfProjectModelElement[0]);
+ for (ITmfProjectModelElement element : traces) {
+ if (element instanceof TmfTraceElement) {
+ TmfTraceElement trace = (TmfTraceElement) element;
+ IResource resource = trace.getResource();
- /* Close the trace if open */
- trace.closeEditors();
+ /* Close the trace if open */
+ trace.closeEditors();
- IPath path = resource.getLocation();
- if (path != null) {
- /* Delete supplementary files */
- trace.deleteSupplementaryFolder();
- }
+ IPath path = resource.getLocation();
+ if (path != null) {
+ /* Delete supplementary files */
+ trace.deleteSupplementaryFolder();
+ }
- /* Finally, delete the trace */
- try {
- resource.delete(true, new NullProgressMonitor());
- } catch (CoreException e) {
- Activator.getDefault().logError("Error deleting trace element", e);
+ /* Finally, delete the trace */
+ try {
+ resource.delete(true, new NullProgressMonitor());
+ } catch (CoreException e) {
+ Activator.getDefault().logError("Error deleting trace element", e);
+ }
}
}
}
import org.eclipse.tracecompass.tmf.ui.project.model.TmfAnalysisElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfViewsElement;
import org.eclipse.tracecompass.tmf.ui.tests.shared.ProjectModelTestData;
import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitTimeoutException;
private TmfTraceElement getTraceElement() {
TmfTraceElement trace = null;
- for (ITmfProjectModelElement element : fixture.getTracesFolder().getChildren()) {
+ final TmfTraceFolder tracesFolder = fixture.getTracesFolder();
+ assertNotNull(tracesFolder);
+ for (ITmfProjectModelElement element : tracesFolder.getChildren()) {
if (element instanceof TmfTraceElement) {
TmfTraceElement traceElement = (TmfTraceElement) element;
if (traceElement.getName().equals(ProjectModelTestData.getTraceName())) {
import org.eclipse.tracecompass.tmf.ui.project.model.TmfAnalysisOutputElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.tests.shared.IWaitCondition;
import org.eclipse.tracecompass.tmf.ui.tests.shared.ProjectModelTestData;
import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitTimeoutException;
private TmfTraceElement getTraceElement() {
TmfTraceElement trace = null;
- for (ITmfProjectModelElement element : fixture.getTracesFolder().getChildren()) {
+ final TmfTraceFolder tracesFolder = fixture.getTracesFolder();
+ assertNotNull(tracesFolder);
+ for (ITmfProjectModelElement element : tracesFolder.getChildren()) {
if (element instanceof TmfTraceElement) {
TmfTraceElement traceElement = (TmfTraceElement) element;
if (traceElement.getName().equals(ProjectModelTestData.getTraceName())) {
import org.eclipse.tracecompass.tmf.ui.project.model.TmfOpenTraceHelper;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.tests.shared.ProjectModelTestData;
import org.eclipse.tracecompass.tmf.ui.tests.shared.WaitTimeoutException;
import org.junit.After;
public void testOpenTrace() {
assertNotNull(fixture);
- final TmfTraceElement traceElement = fixture.getTracesFolder().getTraces().get(0);
+ final TmfTraceFolder tracesFolder = fixture.getTracesFolder();
+ assertNotNull(tracesFolder);
+
+ final TmfTraceElement traceElement = tracesFolder.getTraces().get(0);
/*
* Get the trace from the element, it is not opened yet, should be null
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TraceUtils;
import org.eclipse.ui.PlatformUI;
for (IProject project : ResourcesPlugin.getWorkspace().getRoot().getProjects()) {
if (project.hasNature(TmfProjectNature.ID)) {
TmfProjectElement projectElement = TmfProjectRegistry.getProject(project, true);
- for (final TmfTraceElement trace : projectElement.getTracesFolder().getTraces()) {
- if (monitor.isCanceled()) {
- throw new OperationCanceledException();
- }
- if (traceTypeId.equals(trace.getTraceType())) {
- Display.getDefault().syncExec(new Runnable() {
- @Override
- public void run() {
- trace.closeEditors();
- }
- });
- trace.deleteSupplementaryResources();
- trace.refreshSupplementaryFolder();
+ final TmfTraceFolder tracesFolder = projectElement.getTracesFolder();
+ if (tracesFolder != null) {
+ for (final TmfTraceElement trace : tracesFolder.getTraces()) {
+ if (monitor.isCanceled()) {
+ throw new OperationCanceledException();
+ }
+ if (traceTypeId.equals(trace.getTraceType())) {
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ trace.closeEditors();
+ }
+ });
+ trace.deleteSupplementaryResources();
+ trace.refreshSupplementaryFolder();
+ }
}
}
}
// If source resource is a trace, use the trace element
IResource sourceResource = (IResource) source;
TmfProjectElement projectElement = TmfProjectRegistry.getProject(sourceResource.getProject());
- if (projectElement != null && projectElement.getTracesFolder() != null) {
- for (TmfTraceElement trace : projectElement.getTracesFolder().getTraces()) {
- if (trace.getResource().equals(sourceResource)) {
- source = trace;
- break;
+ if (projectElement != null) {
+ TmfTraceFolder tracesFolder = projectElement.getTracesFolder();
+ if (tracesFolder != null) {
+ for (TmfTraceElement trace : tracesFolder.getTraces()) {
+ if (trace.getResource().equals(sourceResource)) {
+ source = trace;
+ break;
+ }
}
}
}
IResource traceResource = sourceResource;
- IPath tracesFolderPath = targetExperiment.getProject().getTracesFolder().getPath();
+ TmfTraceFolder tracesFolder = targetExperiment.getProject().getTracesFolder();
+ if (tracesFolder == null) {
+ return null;
+ }
+
+ IPath tracesFolderPath = tracesFolder.getPath();
if (tracesFolderPath.isPrefixOf(sourceResource.getFullPath())) {
String elementPath = sourceResource.getFullPath().makeRelativeTo(tracesFolderPath).toString();
for (TmfTraceElement trace : targetExperiment.getTraces()) {
}
} else {
String targetName = sourceResource.getName();
- for (ITmfProjectModelElement element : targetExperiment.getProject().getTracesFolder().getChildren()) {
+ for (ITmfProjectModelElement element : tracesFolder.getChildren()) {
if (element.getName().equals(targetName)) {
targetName = promptRename(element);
if (targetName == null) {
}
try {
if (operation == DND.DROP_COPY && !sourceResource.isLinked()) {
- IPath destination = targetExperiment.getProject().getTracesFolder().getResource().getFullPath().addTrailingSeparator().append(targetName);
+ IPath destination = tracesFolder.getResource().getFullPath().addTrailingSeparator().append(targetName);
sourceResource.copy(destination, false, null);
cleanupBookmarks(destination);
} else {
- createLink(targetExperiment.getProject().getTracesFolder().getResource(), sourceResource, targetName);
+ createLink(tracesFolder.getResource(), sourceResource, targetName);
}
// use the copied resource for the experiment
if (sourceResource.getType() == IResource.FILE) {
- traceResource = targetExperiment.getProject().getTracesFolder().getResource().getFile(targetName);
+ traceResource = tracesFolder.getResource().getFile(targetName);
} else if (sourceResource.getType() == IResource.FOLDER) {
- traceResource = targetExperiment.getProject().getTracesFolder().getResource().getFolder(targetName);
+ traceResource = tracesFolder.getResource().getFolder(targetName);
}
String sourceLocation = sourceResource.getPersistentProperty(TmfCommonConstants.SOURCE_LOCATION);
if (sourceLocation == null) {
}
if (traceResource != null && traceResource.exists()) {
setTraceType(traceResource);
- for (TmfTraceElement trace : targetExperiment.getProject().getTracesFolder().getTraces()) {
+ for (TmfTraceElement trace : tracesFolder.getTraces()) {
if (trace.getResource().equals(traceResource)) {
targetExperiment.addTrace(trace);
targetExperiment.closeEditors();
IResource sourceResource = sourceTrace.getResource();
IResource targetResource = drop(sourceResource, traceFolder, operation);
+ TmfTraceFolder tracesFolder = traceFolder.getProject().getTracesFolder();
- if (targetResource != null) {
- String elementPath = targetResource.getFullPath().makeRelativeTo(traceFolder.getProject().getTracesFolder().getPath()).toString();
+ if ((targetResource != null) && (tracesFolder != null)) {
+ String elementPath = targetResource.getFullPath().makeRelativeTo(tracesFolder.getPath()).toString();
IFolder destinationSupplementaryFolder = traceFolder.getTraceSupplementaryFolder(elementPath);
sourceTrace.copySupplementaryFolder(destinationSupplementaryFolder);
return true;
TmfExperimentElement targetExperiment,
int operation) {
- IPath tracesFolderPath = targetExperiment.getProject().getTracesFolder().getResource().getLocation();
+ TmfTraceFolder tracesFolder = targetExperiment.getProject().getTracesFolder();
+ if (tracesFolder == null) {
+ return false;
+ }
+
+ IPath tracesFolderPath = tracesFolder.getResource().getLocation();
IResource traceResource = null;
if (tracesFolderPath.isPrefixOf(path)) {
String elementPath = path.makeRelativeTo(tracesFolderPath).toString();
return false;
}
}
- traceResource = targetExperiment.getProject().getTracesFolder().getResource().findMember(elementPath);
+ traceResource = tracesFolder.getResource().findMember(elementPath);
} else {
String targetName = path.lastSegment();
- for (ITmfProjectModelElement element : targetExperiment.getProject().getTracesFolder().getChildren()) {
+ for (ITmfProjectModelElement element : tracesFolder.getChildren()) {
if (element.getName().equals(targetName)) {
targetName = promptRename(element);
if (targetName == null) {
}
}
if (operation == DND.DROP_COPY) {
- importTrace(targetExperiment.getProject().getTracesFolder().getResource(), path, targetName);
+ importTrace(tracesFolder.getResource(), path, targetName);
} else {
- createLink(targetExperiment.getProject().getTracesFolder().getResource(), path, targetName);
+ createLink(tracesFolder.getResource(), path, targetName);
}
// use the copied resource for the experiment
File file = new File(path.toString());
if (file.exists() && file.isFile()) {
- traceResource = targetExperiment.getProject().getTracesFolder().getResource().getFile(targetName);
+ traceResource = tracesFolder.getResource().getFile(targetName);
} else if (file.exists() && file.isDirectory()) {
- traceResource = targetExperiment.getProject().getTracesFolder().getResource().getFolder(targetName);
+ traceResource = tracesFolder.getResource().getFolder(targetName);
}
}
if (traceResource != null && traceResource.exists()) {
displayException(e);
}
setTraceType(traceResource);
- for (TmfTraceElement trace : targetExperiment.getProject().getTracesFolder().getTraces()) {
+ for (TmfTraceElement trace : tracesFolder.getTraces()) {
if (trace.getResource().equals(traceResource)) {
targetExperiment.addTrace(trace);
targetExperiment.closeEditors();
import org.eclipse.jface.window.Window;
import org.eclipse.swt.widgets.Display;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TraceUtils;
IContainer parentFolder = oldFolder.getResource().getParent();
final TmfTraceFolder tracesFolder = oldFolder.getProject().getTracesFolder();
final IPath newFolderPath = parentFolder.getFullPath().append(newName);
+ TmfExperimentFolder experimentFolder = oldFolder.getProject().getExperimentsFolder();
+ // Not a standard tracing project
+ if ((tracesFolder == null) || (experimentFolder == null)) {
+ return null;
+ }
WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
@Override
IPath oldFolderElementPath = oldFolder.getPath().makeRelativeTo(tracesFolder.getPath());
IPath newFolderElementPath = oldFolderElementPath.removeLastSegments(1).append(newName);
- for (TmfExperimentElement experiment : oldFolder.getProject().getExperimentsFolder().getExperiments()) {
+ for (TmfExperimentElement experiment : experimentFolder.getExperiments()) {
for (TmfTraceElement oldTrace : experiment.getTraces()) {
if (oldTrace.getElementPath().startsWith(oldFolderElementPath.toString())) {
experiment.removeTrace(oldTrace);
IFolder parentFolder = (IFolder) oldTrace.getParent().getResource();
final TmfTraceFolder tracesFolder = oldTrace.getProject().getTracesFolder();
+ TmfExperimentFolder experimentFolder = oldTrace.getProject().getExperimentsFolder();
+
+ // Not a standard tracing project
+ if ((tracesFolder == null) || (experimentFolder == null)) {
+ return null;
+ }
+
final IPath newPath = parentFolder.getFullPath().append(newName);
WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
return;
}
- TmfExperimentFolder experimentFolder = newTrace.getProject().getExperimentsFolder();
for (final TmfExperimentElement experiment : experimentFolder.getExperiments()) {
for (final TmfTraceElement expTrace : experiment.getTraces()) {
if (expTrace.getElementPath().equals(oldTrace.getElementPath())) {
TmfTraceTypeUIUtils.setTraceType(resource, traceTypeHelper);
TmfExperimentFolder experimentFolder = element.getProject().getExperimentsFolder();
- for (final TmfExperimentElement experiment : experimentFolder.getExperiments()) {
- for (final TmfTraceElement child : experiment.getTraces()) {
- if (child.getName().equals(element.getName())) {
- TmfTraceTypeUIUtils.setTraceType(child.getResource(), traceTypeHelper);
- break;
+ if (experimentFolder != null) {
+ for (final TmfExperimentElement experiment : experimentFolder.getExperiments()) {
+ for (final TmfTraceElement child : experiment.getTraces()) {
+ if (child.getName().equals(element.getName())) {
+ TmfTraceTypeUIUtils.setTraceType(child.getResource(), traceTypeHelper);
+ break;
+ }
}
}
}
import org.eclipse.tracecompass.internal.tmf.ui.editors.ITmfEventsEditorConstants;
import org.eclipse.tracecompass.tmf.core.TmfCommonConstants;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
}
final TmfProjectElement project = TmfProjectRegistry.getProject(file.getProject(), true);
+ TmfTraceFolder tracesFolder = project.getTracesFolder();
// Check for experiments, traces which are folders or traces which are files
if (ITmfEventsEditorConstants.EXPERIMENT_INPUT_TYPE_CONSTANTS.contains(traceTypeId)) {
+ TmfExperimentFolder experimentFolder = project.getExperimentsFolder();
// Case 1: Experiment
- for (final TmfExperimentElement experimentElement : project.getExperimentsFolder().getExperiments()) {
- if (experimentElement.getResource().equals(file.getParent())) {
- return new StructuredSelection(experimentElement);
+ if (experimentFolder != null) {
+ for (final TmfExperimentElement experimentElement : experimentFolder.getExperiments()) {
+ if (experimentElement.getResource().equals(file.getParent())) {
+ return new StructuredSelection(experimentElement);
+ }
}
}
} else if (ITmfEventsEditorConstants.TRACE_INPUT_TYPE_CONSTANTS.contains(traceTypeId)) {
// Case 2: Trace that is a folder
- for (final TmfTraceElement traceElement : project.getTracesFolder().getTraces()) {
- if (traceElement.getResource().equals(file.getParent())) {
- return new StructuredSelection(traceElement);
+
+ if (tracesFolder != null) {
+ for (final TmfTraceElement traceElement : tracesFolder.getTraces()) {
+ if (traceElement.getResource().equals(file.getParent())) {
+ return new StructuredSelection(traceElement);
+ }
}
}
} else {
// Case 3: Trace that is a file
- for (final TmfTraceElement traceElement : project.getTracesFolder().getTraces()) {
- if (traceElement.getResource().equals(file)) {
- return new StructuredSelection(traceElement);
+ if (tracesFolder != null) {
+ for (final TmfTraceElement traceElement : tracesFolder.getTraces()) {
+ if (traceElement.getResource().equals(file)) {
+ return new StructuredSelection(traceElement);
+ }
}
}
}
TmfProjectElement project = TmfProjectRegistry.getProject(fSelectedProject, true);
TmfTraceFolder tracesFolder = project.getTracesFolder();
- List<TmfTraceElement> traces = tracesFolder.getTraces();
- TmfTraceElement[] array = traces.toArray(new TmfTraceElement[] {});
- traceViewer.setInput(array);
- traceViewer.refresh();
- fTraceTable.select(0);
- fTraceTable.notifyListeners(SWT.Selection, new Event());
+ TmfTraceElement[] array = new TmfTraceElement[0];
+ if (tracesFolder != null) {
+ List<TmfTraceElement> traces = tracesFolder.getTraces();
+ array = traces.toArray(new TmfTraceElement[] {});
+ traceViewer.setInput(array);
+ traceViewer.refresh();
+ }
+ if (array.length > 0) {
+ fTraceTable.select(0);
+ fTraceTable.notifyListeners(SWT.Selection, new Event());
+ }
getWizard().getContainer().updateButtons();
}
});
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageTraceElement;
import org.eclipse.tracecompass.tmf.core.TmfCommonConstants;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TraceUtils;
import org.eclipse.ui.internal.wizards.datatransfer.ArchiveFileExportOperation;
import org.w3c.dom.Document;
Document doc = traceNode.getOwnerDocument();
TmfTraceElement traceElement = ((TracePackageTraceElement) element.getParent()).getTraceElement();
IResource resource = traceElement.getResource();
- IPath traceFolderPath = traceElement.getProject().getTracesFolder().getPath();
+
+ final TmfTraceFolder tracesFolder = traceElement.getProject().getTracesFolder();
+ if (tracesFolder == null) {
+ return;
+ }
+ IPath traceFolderPath = tracesFolder.getPath();
// project/Traces/A/B/Kernel -> A/B/Kernel
IPath relativeToExportFolder = resource.getFullPath().makeRelativeTo(traceFolderPath);
ArchiveFile archiveFile = getSpecifiedArchiveFile();
existingTrace.refreshSupplementaryFolder();
// Project/Traces/A/B -> A/B
- IPath traceFolderRelativePath = fTmfTraceFolder.getPath().makeRelativeTo(fTmfTraceFolder.getProject().getTracesFolder().getPath());
+ final TmfTraceFolder tracesFolder = fTmfTraceFolder.getProject().getTracesFolder();
+ if (tracesFolder == null) {
+ return new Status(IStatus.ERROR, Activator.PLUGIN_ID, org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.Messages.TracePackage_ErrorOperation);
+ }
+ IPath traceFolderRelativePath = fTmfTraceFolder.getPath().makeRelativeTo(tracesFolder.getPath());
// Project/.tracing/A/B/
IFolder traceSupplementaryFolder = fTmfTraceFolder.getTraceSupplementaryFolder(traceFolderRelativePath.toString());
IPath destinationContainerPath = traceSupplementaryFolder.getFullPath();
import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
import org.eclipse.tracecompass.tmf.ui.project.model.Messages;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfOpenTraceHelper;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
+import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceTypeUIUtils;
import org.eclipse.tracecompass.tmf.ui.viewers.events.TmfEventsTable;
import org.eclipse.ui.IEditorInput;
if (traceTypeId == null) {
throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
}
+
if (ITmfEventsEditorConstants.EXPERIMENT_INPUT_TYPE_CONSTANTS.contains(traceTypeId)) {
// Special case: experiment bookmark resource
final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
if (project == null) {
throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
}
- for (final TmfExperimentElement experimentElement : project.getExperimentsFolder().getExperiments()) {
- if (experimentElement.getResource().equals(fFile.getParent())) {
- setPartName(experimentElement.getName());
- super.setSite(site);
- super.setInput(fileEditorInput);
- TmfOpenTraceHelper.reopenTraceFromElement(experimentElement, this);
- return;
+ TmfExperimentFolder experimentFolder = project.getExperimentsFolder();
+ if (experimentFolder != null) {
+ for (final TmfExperimentElement experimentElement : experimentFolder.getExperiments()) {
+ if (experimentElement.getResource().equals(fFile.getParent())) {
+ setPartName(experimentElement.getName());
+ super.setSite(site);
+ super.setInput(fileEditorInput);
+ TmfOpenTraceHelper.reopenTraceFromElement(experimentElement, this);
+ return;
+ }
}
}
} else if (ITmfEventsEditorConstants.TRACE_INPUT_TYPE_CONSTANTS.contains(traceTypeId)) {
// Special case: trace bookmark resource
final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
- for (final TmfTraceElement traceElement : project.getTracesFolder().getTraces()) {
- if (traceElement.getResource().equals(fFile.getParent())) {
- setPartName(traceElement.getElementPath());
- super.setSite(site);
- super.setInput(fileEditorInput);
- TmfOpenTraceHelper.reopenTraceFromElement(traceElement, this);
- return;
+ final TmfTraceFolder tracesFolder = project.getTracesFolder();
+ if (tracesFolder != null) {
+ for (final TmfTraceElement traceElement : tracesFolder.getTraces()) {
+ if (traceElement.getResource().equals(fFile.getParent())) {
+ setPartName(traceElement.getElementPath());
+ super.setSite(site);
+ super.setInput(fileEditorInput);
+ TmfOpenTraceHelper.reopenTraceFromElement(traceElement, this);
+ return;
+ }
}
}
} else {
final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
- for (final TmfTraceElement traceElement : project.getTracesFolder().getTraces()) {
- if (traceElement.getResource().equals(fFile)) {
- setPartName(traceElement.getElementPath());
- super.setSite(site);
- super.setInput(fileEditorInput);
- TmfOpenTraceHelper.reopenTraceFromElement(traceElement, this);
- return;
+ final TmfTraceFolder tracesFolder = project.getTracesFolder();
+ if (tracesFolder != null) {
+ for (final TmfTraceElement traceElement : tracesFolder.getTraces()) {
+ if (traceElement.getResource().equals(fFile)) {
+ setPartName(traceElement.getElementPath());
+ super.setSite(site);
+ super.setInput(fileEditorInput);
+ TmfOpenTraceHelper.reopenTraceFromElement(traceElement, this);
+ return;
+ }
}
}
}
/** Trace not found */
public static String TmfOpenTraceHelper_TraceNotFound;
-
+ /**
+ * Error when experiment folder doesn't exists
+ * @since 2.3
+ */
+ public static String TmfProject_ExperimentFolderNotExists;
+ /**
+ * Error when traces folder doesn't exists
+ * @since 2.3
+ */
+ public static String TmfProject_TracesFolderNotExists;
static {
// initialize resource bundle
NLS.initializeMessages(BUNDLE_NAME, Messages.class);
}
/** Get base path for resource */
- IPath path = getProject().getTracesFolder().getPath();
+ final TmfTraceFolder tracesFolder = getProject().getTracesFolder();
+ if (tracesFolder == null) {
+ return;
+ }
+ IPath path = tracesFolder.getPath();
IResource resource = getResource();
if (resource instanceof IFolder) {
path = ((IFolder) resource).getFullPath();
import org.eclipse.core.runtime.InvalidRegistryObjectException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.graphics.Image;
@Override
public IFile createBookmarksFile() throws CoreException {
- return createBookmarksFile(getProject().getExperimentsFolder().getResource(), ITmfEventsEditorConstants.EXPERIMENT_EDITOR_INPUT_TYPE);
+ TmfExperimentFolder experimentFolder = getProject().getExperimentsFolder();
+ if (experimentFolder == null) {
+ throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.TmfProject_ExperimentFolderNotExists));
+ }
+ return createBookmarksFile(experimentFolder.getResource(), ITmfEventsEditorConstants.EXPERIMENT_EDITOR_INPUT_TYPE);
}
@Override
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
+import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.swt.graphics.Image;
/**
// Attributes
// ------------------------------------------------------------------------
- private TmfTraceFolder fTraceFolder = null;
- private TmfExperimentFolder fExperimentFolder = null;
+ @Nullable private TmfTraceFolder fTraceFolder = null;
+ @Nullable private TmfExperimentFolder fExperimentFolder = null;
// ------------------------------------------------------------------------
// Constructor
* Returns the containing trace folder element.
* @return the TMF trace folder element.
*/
+ @Nullable
public TmfTraceFolder getTracesFolder() {
return fTraceFolder;
}
* Returns the containing experiment folder element.
* @return the TMF experiment folder element.
*/
- public TmfExperimentFolder getExperimentsFolder() {
+ @Nullable public TmfExperimentFolder getExperimentsFolder() {
return fExperimentFolder;
}
if (tmfProjectElement == null) {
return;
}
- final List<TmfTraceElement> traces = tmfProjectElement.getTracesFolder().getTraces();
- if (!traces.isEmpty()) {
- // Close editors in UI Thread
- Display.getDefault().syncExec(new Runnable() {
- @Override
- public void run() {
- for (TmfTraceElement traceElement : traces) {
- traceElement.closeEditors();
+ TmfTraceFolder tracesFolder = tmfProjectElement.getTracesFolder();
+ if (tracesFolder != null) {
+ final List<TmfTraceElement> traces = tracesFolder.getTraces();
+ if (!traces.isEmpty()) {
+ // Close editors in UI Thread
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ for (TmfTraceElement traceElement : traces) {
+ traceElement.closeEditors();
+ }
}
- }
- });
+ });
+ }
}
}
} catch (CoreException e) {
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.URIUtil;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.osgi.util.NLS;
public IFile createBookmarksFile() throws CoreException {
IFile file = getBookmarksFile();
if (getResource() instanceof IFolder) {
- return createBookmarksFile(getProject().getTracesFolder().getResource(), ITmfEventsEditorConstants.TRACE_EDITOR_INPUT_TYPE);
+ TmfTraceFolder tracesFolder = getProject().getTracesFolder();
+ if (tracesFolder == null) {
+ throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.TmfProject_TracesFolderNotExists));
+ }
+ return createBookmarksFile(tracesFolder.getResource(), ITmfEventsEditorConstants.TRACE_EDITOR_INPUT_TYPE);
}
return file;
}
// If trace is under an experiment, return original trace from the
// traces folder
if (getParent() instanceof TmfExperimentElement) {
- for (TmfTraceElement aTrace : getProject().getTracesFolder().getTraces()) {
- if (aTrace.getElementPath().equals(getElementPath())) {
- return aTrace;
+ TmfTraceFolder tracesFolder = getProject().getTracesFolder();
+ if (tracesFolder != null) {
+ for (TmfTraceElement aTrace : tracesFolder.getTraces()) {
+ if (aTrace.getElementPath().equals(getElementPath())) {
+ return aTrace;
+ }
}
}
}
// Close experiments that contain the trace if open
if (getParent() instanceof TmfTraceFolder) {
TmfExperimentFolder experimentsFolder = getProject().getExperimentsFolder();
- for (TmfExperimentElement experiment : experimentsFolder.getExperiments()) {
- for (TmfTraceElement trace : experiment.getTraces()) {
- if (trace.getElementPath().equals(getElementPath())) {
- experiment.closeEditors();
- break;
+ if (experimentsFolder != null) {
+ for (TmfExperimentElement experiment : experimentsFolder.getExperiments()) {
+ for (TmfTraceElement trace : experiment.getTraces()) {
+ if (trace.getElementPath().equals(getElementPath())) {
+ experiment.closeEditors();
+ break;
+ }
}
}
}
TmfExperimentFolder experimentFolder = getProject().getExperimentsFolder();
// Propagate the removal to traces
- for (TmfExperimentElement experiment : experimentFolder.getExperiments()) {
- List<TmfTraceElement> toRemove = new LinkedList<>();
- for (TmfTraceElement trace : experiment.getTraces()) {
- if (trace.getElementPath().equals(getElementPath())) {
- toRemove.add(trace);
+ if (experimentFolder != null) {
+ for (TmfExperimentElement experiment : experimentFolder.getExperiments()) {
+ List<TmfTraceElement> toRemove = new LinkedList<>();
+ for (TmfTraceElement trace : experiment.getTraces()) {
+ if (trace.getElementPath().equals(getElementPath())) {
+ toRemove.add(trace);
+ }
+ }
+ for (TmfTraceElement child : toRemove) {
+ experiment.removeTrace(child);
}
- }
- for (TmfTraceElement child : toRemove) {
- experiment.removeTrace(child);
}
}
-
// Delete supplementary files
deleteSupplementaryFolder();
resource.setPersistentProperty(TmfCommonConstants.TRACETYPE, traceTypeId);
TmfProjectElement tmfProject = TmfProjectRegistry.getProject(resource.getProject(), true);
- if (tmfProject.getTracesFolder().getPath().isPrefixOf(resource.getFullPath())) {
- String elementPath = resource.getFullPath().makeRelativeTo(tmfProject.getTracesFolder().getPath()).toString();
- refreshTraceElement(tmfProject.getTracesFolder().getTraces(), elementPath);
- } else if (resource.getParent().equals(tmfProject.getExperimentsFolder().getResource())) {
- /* The trace type to set is for an experiment */
- for (TmfExperimentElement experimentElement : tmfProject.getExperimentsFolder().getExperiments()) {
- if (resource.equals(experimentElement.getResource())) {
- experimentElement.refreshTraceType();
- break;
- }
+ TmfTraceFolder tracesFolder = tmfProject.getTracesFolder();
+ TmfExperimentFolder experimentsFolder = tmfProject.getExperimentsFolder();
+ if (tracesFolder != null) {
+ if (tracesFolder.getPath().isPrefixOf(resource.getFullPath())) {
+ String elementPath = resource.getFullPath().makeRelativeTo(tracesFolder.getPath()).toString();
+ refreshTraceElement(tracesFolder.getTraces(), elementPath);
}
- } else {
- for (TmfExperimentElement experimentElement : tmfProject.getExperimentsFolder().getExperiments()) {
- if (experimentElement.getPath().isPrefixOf(resource.getFullPath())) {
- String elementPath = resource.getFullPath().makeRelativeTo(experimentElement.getPath()).toString();
- refreshTraceElement(experimentElement.getTraces(), elementPath);
- break;
+ }
+ if ((tracesFolder == null) || (experimentsFolder != null)) {
+ if (experimentsFolder != null) {
+ if (resource.getParent().equals(experimentsFolder.getResource())) {
+ /* The trace type to set is for an experiment */
+ for (TmfExperimentElement experimentElement : experimentsFolder.getExperiments()) {
+ if (resource.equals(experimentElement.getResource())) {
+ experimentElement.refreshTraceType();
+ break;
+ }
+ }
+ } else {
+ for (TmfExperimentElement experimentElement : experimentsFolder.getExperiments()) {
+ if (experimentElement.getPath().isPrefixOf(resource.getFullPath())) {
+ String elementPath = resource.getFullPath().makeRelativeTo(experimentElement.getPath()).toString();
+ refreshTraceElement(experimentElement.getTraces(), elementPath);
+ break;
+ }
+ }
}
}
}
+
if (refresh) {
tmfProject.refresh();
}
TmfOpenTraceHelper_ErrorElement=Error opening {0}.
TmfOpenTraceHelper_InitError = Error initializing trace.
TmfOpenTraceHelper_TraceNotFound = Trace {0} not found.
+
+TmfProject_ExperimentFolderNotExists = Root experiment folder doesn't exist in project.
+TmfProject_TracesFolderNotExists = Root traces folder doesn't exist in project
projects / deliverable / tracecompass.git / commitdiff
