Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/project/model/TmfTraceElement.java')
-rw-r--r--tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/project/model/TmfTraceElement.java699
1 files changed, 699 insertions, 0 deletions
diff --git a/tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/project/model/TmfTraceElement.java b/tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/project/model/TmfTraceElement.java
new file mode 100644
index 0000000000..fe52410695
--- /dev/null
+++ b/tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/project/model/TmfTraceElement.java
@@ -0,0 +1,699 @@
+/*******************************************************************************
+ * Copyright (c) 2010, 2015 Ericsson, École Polytechnique de Montréal
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Francois Chouinard - Initial API and implementation
+ * Bernd Hufmann - Added supplementary files handling
+ * Geneviève Bastien - Moved supplementary files handling to parent class,
+ * added code to copy trace
+ * Patrick Tasse - Close editors to release resources
+ * Jean-Christian Kouame - added trace properties to be shown into
+ * the properties view
+ * Geneviève Bastien - Moved trace type related methods to parent class
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.tmf.ui.project.model;
+
+import java.util.Arrays;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.filesystem.EFS;
+import org.eclipse.core.filesystem.IFileInfo;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.URIUtil;
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.tracecompass.internal.tmf.ui.Activator;
+import org.eclipse.tracecompass.internal.tmf.ui.editors.ITmfEventsEditorConstants;
+import org.eclipse.tracecompass.tmf.core.TmfCommonConstants;
+import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
+import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomTxtEvent;
+import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomTxtTrace;
+import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomTxtTraceDefinition;
+import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomXmlEvent;
+import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomXmlTrace;
+import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomXmlTraceDefinition;
+import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
+import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;
+import org.eclipse.tracecompass.tmf.core.synchronization.TimestampTransformFactory;
+import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceProperties;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.ui.editors.TmfEventsEditor;
+import org.eclipse.tracecompass.tmf.ui.properties.ReadOnlyTextPropertyDescriptor;
+import org.eclipse.ui.IActionFilter;
+import org.eclipse.ui.views.properties.IPropertyDescriptor;
+import org.eclipse.ui.views.properties.IPropertySource2;
+
+import com.ibm.icu.text.DateFormat;
+import com.ibm.icu.text.NumberFormat;
+
+/**
+ * Implementation of trace model element representing a trace. It provides
+ * methods to instantiate <code>ITmfTrace</code> and <code>ITmfEvent</code> as
+ * well as editor ID from the trace type extension definition.
+ *
+ * @version 1.0
+ * @author Francois Chouinard
+ */
+public class TmfTraceElement extends TmfCommonProjectElement implements IActionFilter, IPropertySource2 {
+
+ // ------------------------------------------------------------------------
+ // Constants
+ // ------------------------------------------------------------------------
+
+ // Other attributes
+ /**
+ * Bundle attribute name
+ */
+ public static final String BUNDLE = "bundle"; //$NON-NLS-1$
+ /**
+ * IsLinked attribute name.
+ */
+ public static final String IS_LINKED = "isLinked"; //$NON-NLS-1$
+
+ // Property View stuff
+ private static final String sfResourcePropertiesCategory = Messages.TmfTraceElement_ResourceProperties;
+ private static final String sfName = Messages.TmfTraceElement_Name;
+ private static final String sfPath = Messages.TmfTraceElement_Path;
+ private static final String sfLocation = Messages.TmfTraceElement_Location;
+ private static final String sfTraceType = Messages.TmfTraceElement_EventType;
+ private static final String sfIsLinked = Messages.TmfTraceElement_IsLinked;
+ private static final String sfSourceLocation = Messages.TmfTraceElement_SourceLocation;
+ private static final String sfTimeOffset = Messages.TmfTraceElement_TimeOffset;
+ private static final String sfLastModified = Messages.TmfTraceElement_LastModified;
+ private static final String sfSize = Messages.TmfTraceElement_Size;
+ private static final String sfTracePropertiesCategory = Messages.TmfTraceElement_TraceProperties;
+
+ private static final ReadOnlyTextPropertyDescriptor sfNameDescriptor = new ReadOnlyTextPropertyDescriptor(sfName, sfName);
+ private static final ReadOnlyTextPropertyDescriptor sfPathDescriptor = new ReadOnlyTextPropertyDescriptor(sfPath, sfPath);
+ private static final ReadOnlyTextPropertyDescriptor sfLocationDescriptor = new ReadOnlyTextPropertyDescriptor(sfLocation, sfLocation);
+ private static final ReadOnlyTextPropertyDescriptor sfTypeDescriptor = new ReadOnlyTextPropertyDescriptor(sfTraceType, sfTraceType);
+ private static final ReadOnlyTextPropertyDescriptor sfIsLinkedDescriptor = new ReadOnlyTextPropertyDescriptor(sfIsLinked, sfIsLinked);
+ private static final ReadOnlyTextPropertyDescriptor sfSourceLocationDescriptor = new ReadOnlyTextPropertyDescriptor(sfSourceLocation, sfSourceLocation);
+ private static final ReadOnlyTextPropertyDescriptor sfTimeOffsetDescriptor = new ReadOnlyTextPropertyDescriptor(sfTimeOffset, sfTimeOffset);
+ private static final ReadOnlyTextPropertyDescriptor sfLastModifiedDescriptor = new ReadOnlyTextPropertyDescriptor(sfLastModified, sfLastModified);
+ private static final ReadOnlyTextPropertyDescriptor sfSizeDescriptor = new ReadOnlyTextPropertyDescriptor(sfSize, sfSize);
+
+ private static final IPropertyDescriptor[] sfDescriptors = { sfNameDescriptor, sfPathDescriptor, sfLocationDescriptor,
+ sfTypeDescriptor, sfIsLinkedDescriptor, sfSourceLocationDescriptor,
+ sfTimeOffsetDescriptor, sfLastModifiedDescriptor, sfSizeDescriptor };
+
+ static {
+ sfNameDescriptor.setCategory(sfResourcePropertiesCategory);
+ sfPathDescriptor.setCategory(sfResourcePropertiesCategory);
+ sfLocationDescriptor.setCategory(sfResourcePropertiesCategory);
+ sfTypeDescriptor.setCategory(sfResourcePropertiesCategory);
+ sfIsLinkedDescriptor.setCategory(sfResourcePropertiesCategory);
+ sfSourceLocationDescriptor.setCategory(sfResourcePropertiesCategory);
+ sfTimeOffsetDescriptor.setCategory(sfResourcePropertiesCategory);
+ sfLastModifiedDescriptor.setCategory(sfResourcePropertiesCategory);
+ sfSizeDescriptor.setCategory(sfResourcePropertiesCategory);
+ }
+
+ private static final TmfTimestampFormat OFFSET_FORMAT = new TmfTimestampFormat("T.SSS SSS SSS s"); //$NON-NLS-1$
+
+ private static final int FOLDER_MAX_COUNT = 1024;
+
+ // ------------------------------------------------------------------------
+ // Static initialization
+ // ------------------------------------------------------------------------
+
+ // The mapping of available trace type IDs to their corresponding
+ // configuration element
+ private static final Map<String, IConfigurationElement> sfTraceTypeAttributes = new HashMap<>();
+ private static final Map<String, IConfigurationElement> sfTraceTypeUIAttributes = new HashMap<>();
+ private static final Map<String, IConfigurationElement> sfTraceCategories = new HashMap<>();
+
+ /**
+ * Initialize statically at startup by getting extensions from the platform
+ * extension registry.
+ */
+ public static void init() {
+ /* Read the tmf.core "tracetype" extension point */
+ IConfigurationElement[] config = Platform.getExtensionRegistry().getConfigurationElementsFor(TmfTraceType.TMF_TRACE_TYPE_ID);
+ for (IConfigurationElement ce : config) {
+ switch (ce.getName()) {
+ case TmfTraceType.TYPE_ELEM:
+ String traceTypeId = ce.getAttribute(TmfTraceType.ID_ATTR);
+ sfTraceTypeAttributes.put(traceTypeId, ce);
+ break;
+ case TmfTraceType.CATEGORY_ELEM:
+ String categoryId = ce.getAttribute(TmfTraceType.ID_ATTR);
+ sfTraceCategories.put(categoryId, ce);
+ break;
+ default:
+ }
+ }
+
+ /*
+ * Read the corresponding tmf.ui "tracetypeui" extension point for this
+ * trace type, if it exists.
+ */
+ config = Platform.getExtensionRegistry().getConfigurationElementsFor(TmfTraceTypeUIUtils.TMF_TRACE_TYPE_UI_ID);
+ for (IConfigurationElement ce : config) {
+ String elemName = ce.getName();
+ if (TmfTraceTypeUIUtils.TYPE_ELEM.equals(elemName)) {
+ String traceType = ce.getAttribute(TmfTraceTypeUIUtils.TRACETYPE_ATTR);
+ sfTraceTypeUIAttributes.put(traceType, ce);
+ }
+ }
+ }
+
+ // ------------------------------------------------------------------------
+ // Classes
+ // ------------------------------------------------------------------------
+
+ private class FileInfo {
+ long lastModified;
+ long size;
+ int count;
+ }
+
+ // ------------------------------------------------------------------------
+ // Attributes
+ // ------------------------------------------------------------------------
+
+ private FileInfo fFileInfo;
+
+ // ------------------------------------------------------------------------
+ // Constructors
+ // ------------------------------------------------------------------------
+ /**
+ * Constructor. Creates trace model element under the trace folder.
+ *
+ * @param name
+ * The name of trace
+ * @param trace
+ * The trace resource.
+ * @param parent
+ * The parent element (trace folder)
+ */
+ public TmfTraceElement(String name, IResource trace, TmfTraceFolder parent) {
+ super(name, trace, parent);
+ }
+
+ /**
+ * Constructor. Creates trace model element under the experiment folder.
+ *
+ * @param name
+ * The name of trace
+ * @param trace
+ * The trace resource.
+ * @param parent
+ * The parent element (experiment folder)
+ */
+ public TmfTraceElement(String name, IResource trace, TmfExperimentElement parent) {
+ super(name, trace, parent);
+ }
+
+ // ------------------------------------------------------------------------
+ // Operations
+ // ------------------------------------------------------------------------
+
+ /**
+ * Instantiate a <code>ITmfTrace</code> object based on the trace type and
+ * the corresponding extension.
+ *
+ * @return the <code>ITmfTrace</code> or <code>null</code> for an error
+ */
+ @Override
+ public ITmfTrace instantiateTrace() {
+ try {
+
+ // make sure that supplementary folder exists
+ refreshSupplementaryFolder();
+
+ String traceTypeId = getTraceType();
+ if (traceTypeId != null) {
+ if (CustomTxtTrace.isCustomTraceTypeId(traceTypeId)) {
+ for (CustomTxtTraceDefinition def : CustomTxtTraceDefinition.loadAll()) {
+ String id = CustomTxtTrace.buildTraceTypeId(def.categoryName, def.definitionName);
+ if (traceTypeId.equals(id)) {
+ return new CustomTxtTrace(def);
+ }
+ }
+ }
+ if (CustomXmlTrace.isCustomTraceTypeId(traceTypeId)) {
+ for (CustomXmlTraceDefinition def : CustomXmlTraceDefinition.loadAll()) {
+ String id = CustomXmlTrace.buildTraceTypeId(def.categoryName, def.definitionName);
+ if (traceTypeId.equals(id)) {
+ return new CustomXmlTrace(def);
+ }
+ }
+ }
+ IConfigurationElement ce = sfTraceTypeAttributes.get(traceTypeId);
+ if (ce == null) {
+ return null;
+ }
+ ITmfTrace trace = (ITmfTrace) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);
+ return trace;
+ }
+ } catch (CoreException e) {
+ Activator.getDefault().logError("Error instantiating ITmfTrace object for trace " + getName(), e); //$NON-NLS-1$
+ }
+ return null;
+ }
+
+ /**
+ * Instantiate a <code>ITmfEvent</code> object based on the trace type and
+ * the corresponding extension.
+ *
+ * @return the <code>ITmfEvent</code> or <code>null</code> for an error
+ */
+ public ITmfEvent instantiateEvent() {
+ try {
+ String traceTypeId = getTraceType();
+ if (traceTypeId != null) {
+ if (CustomTxtTrace.isCustomTraceTypeId(traceTypeId)) {
+ for (CustomTxtTraceDefinition def : CustomTxtTraceDefinition.loadAll()) {
+ String id = CustomTxtTrace.buildTraceTypeId(def.categoryName, def.definitionName);
+ if (traceTypeId.equals(id)) {
+ return new CustomTxtEvent(def);
+ }
+ }
+ }
+ if (CustomXmlTrace.isCustomTraceTypeId(traceTypeId)) {
+ for (CustomXmlTraceDefinition def : CustomXmlTraceDefinition.loadAll()) {
+ String id = CustomXmlTrace.buildTraceTypeId(def.categoryName, def.definitionName);
+ if (traceTypeId.equals(id)) {
+ return new CustomXmlEvent(def);
+ }
+ }
+ }
+ IConfigurationElement ce = sfTraceTypeAttributes.get(traceTypeId);
+ if (ce == null) {
+ return null;
+ }
+ ITmfEvent event = (ITmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);
+ return event;
+ }
+ } catch (CoreException e) {
+ Activator.getDefault().logError("Error instantiating ITmfEvent object for trace " + getName(), e); //$NON-NLS-1$
+ }
+ return null;
+ }
+
+ @Override
+ public String getEditorId() {
+ String traceTypeId = getTraceType();
+ if (traceTypeId != null) {
+ if (CustomTxtTrace.isCustomTraceTypeId(traceTypeId) || CustomXmlTrace.isCustomTraceTypeId(traceTypeId)) {
+ return TmfEventsEditor.ID;
+ }
+
+ IConfigurationElement ce = sfTraceTypeUIAttributes.get(getTraceType());
+ if (ce == null) {
+ /* This trace type does not define UI attributes */
+ return null;
+ }
+ IConfigurationElement[] defaultEditorCE = ce.getChildren(TmfTraceTypeUIUtils.DEFAULT_EDITOR_ELEM);
+ if (defaultEditorCE.length == 1) {
+ return defaultEditorCE[0].getAttribute(TmfTraceType.ID_ATTR);
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Returns the file resource used to store bookmarks after creating it if
+ * necessary. If the trace resource is a file, it is returned directly. If
+ * the trace resource is a folder, a linked file is returned. The file will
+ * be created if it does not exist.
+ *
+ * @return the bookmarks file
+ * @throws CoreException
+ * if the bookmarks file cannot be created
+ */
+ @Override
+ public IFile createBookmarksFile() throws CoreException {
+ IFile file = getBookmarksFile();
+ if (fResource instanceof IFolder) {
+ return createBookmarksFile(getProject().getTracesFolder().getResource(), ITmfEventsEditorConstants.TRACE_EDITOR_INPUT_TYPE);
+ }
+ return file;
+ }
+
+ /**
+ * Returns the file resource used to store bookmarks. The file may not
+ * exist.
+ *
+ * @return the bookmarks file
+ */
+ @Override
+ public IFile getBookmarksFile() {
+ IFile file = null;
+ if (fResource instanceof IFile) {
+ file = (IFile) fResource;
+ } else if (fResource instanceof IFolder) {
+ final IFolder folder = (IFolder) fResource;
+ file = folder.getFile(getName() + '_');
+ }
+ return file;
+ }
+
+ /**
+ * Returns the <code>TmfTraceElement</code> located under the
+ * <code>TmfTracesFolder</code>.
+ *
+ * @return <code>this</code> if this element is under the
+ * <code>TmfTracesFolder</code> else the corresponding
+ * <code>TmfTraceElement</code> if this element is under
+ * <code>TmfExperimentElement</code>.
+ */
+ public TmfTraceElement getElementUnderTraceFolder() {
+
+ // 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;
+ }
+ }
+ }
+ return this;
+ }
+
+ @Override
+ public String getTypeName() {
+ return Messages.TmfTraceElement_TypeName;
+ }
+
+ // ------------------------------------------------------------------------
+ // IActionFilter
+ // ------------------------------------------------------------------------
+
+ @Override
+ public boolean testAttribute(Object target, String name, String value) {
+ if (name.equals(IS_LINKED)) {
+ boolean isLinked = getResource().isLinked();
+ return Boolean.toString(isLinked).equals(value);
+ }
+ return false;
+ }
+
+ // ------------------------------------------------------------------------
+ // IPropertySource2
+ // ------------------------------------------------------------------------
+
+ @Override
+ public Object getEditableValue() {
+ return null;
+ }
+
+ /**
+ * Get the trace properties of this traceElement if the corresponding trace
+ * is opened in an editor
+ *
+ * @return a map with the names and values of the trace properties
+ * respectively as keys and values
+ */
+ private Map<String, String> getTraceProperties() {
+ for (ITmfTrace openedTrace : TmfTraceManager.getInstance().getOpenedTraces()) {
+ for (ITmfTrace singleTrace : TmfTraceManager.getTraceSet(openedTrace)) {
+ if (getElementUnderTraceFolder().getResource().equals(singleTrace.getResource())) {
+ if (singleTrace instanceof ITmfTraceProperties) {
+ ITmfTraceProperties traceProperties = (ITmfTraceProperties) singleTrace;
+ return traceProperties.getTraceProperties();
+ }
+ }
+ }
+ }
+ return new HashMap<>();
+ }
+
+ @Override
+ public IPropertyDescriptor[] getPropertyDescriptors() {
+ Map<String, String> traceProperties = getTraceProperties();
+ if (!traceProperties.isEmpty()) {
+ IPropertyDescriptor[] propertyDescriptorArray = new IPropertyDescriptor[traceProperties.size() + sfDescriptors.length];
+ int index = 0;
+ for (Map.Entry<String, String> varName : traceProperties.entrySet()) {
+ ReadOnlyTextPropertyDescriptor descriptor = new ReadOnlyTextPropertyDescriptor(this.getName() + "_" + varName.getKey(), varName.getKey()); //$NON-NLS-1$
+ descriptor.setCategory(sfTracePropertiesCategory);
+ propertyDescriptorArray[index] = descriptor;
+ index++;
+ }
+ for (int i = 0; i < sfDescriptors.length; i++) {
+ propertyDescriptorArray[index] = sfDescriptors[i];
+ index++;
+ }
+ return propertyDescriptorArray;
+ }
+ return Arrays.copyOf(sfDescriptors, sfDescriptors.length);
+ }
+
+ @Override
+ public Object getPropertyValue(Object id) {
+
+ if (sfName.equals(id)) {
+ return getName();
+ }
+
+ if (sfPath.equals(id)) {
+ return getPath().toString();
+ }
+
+ if (sfLocation.equals(id)) {
+ return URIUtil.toUnencodedString(getLocation());
+ }
+
+ if (sfIsLinked.equals(id)) {
+ return Boolean.valueOf(getResource().isLinked()).toString();
+ }
+
+ if (sfSourceLocation.equals(id)) {
+ try {
+ String sourceLocation = getElementUnderTraceFolder().getResource().getPersistentProperty(TmfCommonConstants.SOURCE_LOCATION);
+ if (sourceLocation != null) {
+ return sourceLocation;
+ }
+ } catch (CoreException e) {
+ }
+ return ""; //$NON-NLS-1$
+ }
+
+ if (sfLastModified.equals(id)) {
+ FileInfo fileInfo = getFileInfo();
+ if (fileInfo == null) {
+ return ""; //$NON-NLS-1$
+ }
+ long date = fileInfo.lastModified;
+ DateFormat format = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.MEDIUM);
+ return format.format(new Date(date));
+ }
+
+ if (sfSize.equals(id)) {
+ FileInfo fileInfo = getFileInfo();
+ if (fileInfo == null) {
+ return ""; //$NON-NLS-1$
+ }
+ if (getResource() instanceof IFolder) {
+ if (fileInfo.count <= FOLDER_MAX_COUNT) {
+ return NLS.bind(Messages.TmfTraceElement_FolderSizeString,
+ NumberFormat.getInstance().format(fileInfo.size), fileInfo.count);
+ }
+ return NLS.bind(Messages.TmfTraceElement_FolderSizeOverflowString,
+ NumberFormat.getInstance().format(fileInfo.size), FOLDER_MAX_COUNT);
+ }
+ return NLS.bind(Messages.TmfTraceElement_FileSizeString, NumberFormat.getInstance().format(fileInfo.size));
+ }
+
+ if (sfTraceType.equals(id)) {
+ if (getTraceType() != null) {
+ TraceTypeHelper helper = TmfTraceType.getTraceType(getTraceType());
+ if (helper != null) {
+ return helper.getLabel();
+ }
+ }
+ return ""; //$NON-NLS-1$
+ }
+
+ if (sfTimeOffset.equals(id)) {
+ long offset = TimestampTransformFactory.getTimestampTransform(getElementUnderTraceFolder().getResource()).transform(0);
+ if (offset != 0) {
+ return OFFSET_FORMAT.format(offset);
+ }
+ return ""; //$NON-NLS-1$
+ }
+
+ Map<String, String> traceProperties = getTraceProperties();
+ if (id != null && !traceProperties.isEmpty()) {
+ String key = (String) id;
+ key = key.substring(this.getName().length() + 1); // remove name_
+ String value = traceProperties.get(key);
+ return value;
+ }
+
+ return null;
+ }
+
+ private FileInfo getFileInfo() {
+ /* FileInfo is needed for both 'last modified' and 'size' properties.
+ * It is freshly computed for one, and reused for the other, then
+ * cleared so that the information can be refreshed the next time.
+ */
+ FileInfo fileInfo;
+ if (fFileInfo == null) {
+ try {
+ fileInfo = computeFileInfo(new FileInfo(), getResource());
+ } catch (CoreException e) {
+ return null;
+ }
+ fFileInfo = fileInfo;
+ } else {
+ fileInfo = fFileInfo;
+ fFileInfo = null;
+ }
+ return fileInfo;
+ }
+
+ private FileInfo computeFileInfo(FileInfo fileInfo, IResource resource) throws CoreException {
+ if (fileInfo == null || fileInfo.count > FOLDER_MAX_COUNT) {
+ return fileInfo;
+ }
+ if (resource instanceof IFolder) {
+ IFolder folder = (IFolder) resource;
+ for (IResource member : folder.members()) {
+ computeFileInfo(fileInfo, member);
+ }
+ return fileInfo;
+ }
+ IFileInfo info = EFS.getStore(resource.getLocationURI()).fetchInfo();
+ fileInfo.lastModified = Math.max(fileInfo.lastModified, info.getLastModified());
+ fileInfo.size += info.getLength();
+ fileInfo.count++;
+ return fileInfo;
+ }
+
+ @Override
+ public void resetPropertyValue(Object id) {
+ }
+
+ @Override
+ public void setPropertyValue(Object id, Object value) {
+ }
+
+ @Override
+ public boolean isPropertyResettable(Object id) {
+ return false;
+ }
+
+ @Override
+ public boolean isPropertySet(Object id) {
+ return false;
+ }
+
+ /**
+ * Copy this trace in the trace folder. No other parameters are mentioned so
+ * the trace is copied in this element's project trace folder
+ *
+ * @param newName
+ * The new trace name
+ * @return the new Resource object
+ */
+ public TmfTraceElement copy(String newName) {
+ TmfTraceFolder folder = (TmfTraceFolder) getParent();
+ IResource res = super.copy(newName, false);
+ for (TmfTraceElement trace : folder.getTraces()) {
+ if (trace.getResource().equals(res)) {
+ return trace;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Close opened editors associated with this trace.
+ */
+ @Override
+ public void closeEditors() {
+ super.closeEditors();
+
+ // 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;
+ }
+ }
+ }
+ } else if (getParent() instanceof TmfExperimentElement) {
+ TmfExperimentElement experiment = (TmfExperimentElement) getParent();
+ experiment.closeEditors();
+ }
+ }
+
+ /**
+ * Delete the trace resource, remove it from experiments and delete its
+ * supplementary files
+ *
+ * @param progressMonitor
+ * a progress monitor, or null if progress reporting is not
+ * desired
+ *
+ * @throws CoreException
+ * thrown when IResource.delete fails
+ */
+ public void delete(IProgressMonitor progressMonitor) throws CoreException {
+ // Close editors in UI Thread
+ Display.getDefault().syncExec(new Runnable() {
+ @Override
+ public void run() {
+ closeEditors();
+ }
+ });
+
+ IPath path = fResource.getLocation();
+ if (path != null) {
+ if (getParent() instanceof TmfTraceFolder) {
+ 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);
+ }
+ }
+ for (TmfTraceElement child : toRemove) {
+ experiment.removeTrace(child);
+ }
+ }
+
+ // Delete supplementary files
+ deleteSupplementaryFolder();
+
+ } else if (getParent() instanceof TmfExperimentElement) {
+ TmfExperimentElement experimentElement = (TmfExperimentElement) getParent();
+ experimentElement.removeTrace(this);
+ }
+ }
+
+ // Finally, delete the trace
+ fResource.delete(true, progressMonitor);
+ }
+
+}

Back to the top