org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTRangeUpdate.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * 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: Alvaro Sanchez-Leon - Initial implementation
  10  *******************************************************************************/
  11 package org.eclipse.linuxtools.lttng.ui.views.common;
  12
  13 import org.eclipse.linuxtools.lttng.event.LttngEvent;
  14 import org.eclipse.linuxtools.lttng.event.LttngEventContent;
  15 import org.eclipse.linuxtools.lttng.event.LttngEventField;
  16 import org.eclipse.linuxtools.lttng.state.StateStrings.Fields;
  17 import org.eclipse.linuxtools.lttng.state.evProcessor.IEventProcessing;
  18 import org.eclipse.linuxtools.lttng.state.model.LttngTraceState;
  19 import org.eclipse.linuxtools.lttng.ui.TraceDebug;
  20 import org.eclipse.linuxtools.tmf.event.TmfEventField;
  21 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  22
  23 public abstract class AbsTRangeUpdate implements IEventProcessing {
  24
  25     private static final long MINORBITS = 20;
  26
  27         // ========================================================================
  28         // General methods
  29         // =======================================================================
  30
  31     /**
  32      * Get the mkdev node id<br>
  33      * <br>
  34      * This is an implementation of a KERNEL macro used in Lttv
  35      *
  36      */
  37     public long getMkdevId(long major, long minor) {
  38         return (((major) << MINORBITS) | (minor));
  39     }
  40
  41         /**
  42          * Get the pixels per Nano second, either from active widgets or initialise
  43          * with the experiment time range values
  44          *
  45          * @param traceSt
  46          * @param params
  47          *
  48          * @return double
  49          */
  50     protected double getPixelsPerNs(LttngTraceState traceSt, ParamsUpdater params) {
  51         double pixPerNs = params.getPixelsPerNs();
  52         if (pixPerNs == 0) {
  53             TmfTimeRange tsetRange = traceSt.getInputDataRef().getExperimentTimeWindow();
  54
  55             long startTime = tsetRange.getStartTime().getValue();
  56             long endTime = tsetRange.getEndTime().getValue();
  57             long delta = endTime - startTime;
  58
  59             if (delta > 0) {
  60                 pixPerNs = (double) params.getWidth() / (double) delta;
  61                 params.setPixelsPerNs(pixPerNs);
  62             }
  63         }
  64         return pixPerNs;
  65     }
  66
  67     /**
  68          * protected method used when only one Field is expected with Type "Long" if
  69          * the number of fields is greater, the first field is returned and a
  70          * tracing message is sent Null is returned if the value could not be
  71          * extracted.
  72          *
  73          * @param trcEvent
  74          * @param traceSt
  75          * @param expectedNumFields
  76          * @return
  77          */
  78         protected Long getDField(LttngEvent trcEvent, LttngTraceState traceSt,
  79                         Fields expectedField) {
  80                 Long fieldVal = null;
  81                 TmfEventField[] fields = trcEvent.getContent().getFields();
  82                 String[] fieldLabels = trcEvent.getContent().getFormat().getLabels();
  83
  84                 // Only one field expected
  85                 if (fields.length != 1 || fieldLabels.length != 1) {
  86                         StringBuilder sb = new StringBuilder(
  87                                         "Unexpected number of fields received: " + fields.length
  88                                                         + " for Event: " + trcEvent.getMarkerName()
  89                                                         + "\n\t\tFields: ");
  90
  91                         for (TmfEventField field : fields) {
  92                                 sb.append(((LttngEventField) field).getName() + " ");
  93                         }
  94
  95                         TraceDebug.debug(sb.toString());
  96                         if (fields.length == 0) {
  97                                 return null;
  98                         }
  99                 }
 100
 101                 LttngEventField field = (LttngEventField) fields[0];
 102                 String fieldname = field.getName();
 103                 String expectedFieldName = expectedField.getInName();
 104                 if (fieldname.equals(expectedFieldName)) {
 105                         Object fieldObj = field.getValue();
 106                         if (fieldObj instanceof Long) {
 107                                 // Expected value found
 108                                 fieldVal = (Long) field.getValue();
 109                         } else {
 110                                 if (TraceDebug.isDEBUG()) {
 111                                         TraceDebug
 112                                                         .debug("Unexpected field Type. Expected: Long, Received: "
 113                                                                         + fieldObj.getClass().getSimpleName());
 114                                 }
 115                                 return null;
 116                         }
 117                 } else {
 118                         TraceDebug.debug("Unexpected field received: " + fieldname
 119                                         + " Expected: " + expectedFieldName);
 120                         return null;
 121                 }
 122
 123                 return fieldVal;
 124         }
 125
 126         /**
 127          * protected method used when a Field is requested among several available
 128          * fields and the expected type is Long
 129          *
 130          * @param trcEvent
 131          * @param traceSt
 132          * @param expectedNumFields
 133          * @return
 134          */
 135         protected Long getAFieldLong(LttngEvent trcEvent, LttngTraceState traceSt,
 136                         Fields expectedField) {
 137                 Long fieldVal = null;
 138                 TmfEventField[] fields = ((LttngEventContent) trcEvent.getContent())
 139                                 .getFields(trcEvent);
 140
 141                 // At least one field expected
 142                 if (fields.length == 0) {
 143                         TraceDebug.debug("Unexpected number of fields received: "
 144                                         + fields.length);
 145                         return null;
 146                 }
 147
 148                 LttngEventField field;
 149                 String fieldname;
 150                 String expectedFieldName = expectedField.getInName();
 151                 for (int i = 0; i < fields.length; i++) {
 152                         field = (LttngEventField) fields[i];
 153                         fieldname = field.getName();
 154                         if (fieldname.equals(expectedFieldName)) {
 155                                 Object fieldObj = field.getValue();
 156                                 if (fieldObj instanceof Long) {
 157                                         // Expected value found
 158                                         fieldVal = (Long) field.getValue();
 159                                         // if (expectedField == Fields.LTT_FIELD_TYPE) {
 160                                         // TraceDebug.debug("Field Type value is: " + fieldVal);
 161                                         // }
 162                                         break;
 163                                 } else {
 164                                         if (TraceDebug.isDEBUG()) {
 165                                                 TraceDebug
 166                                                                 .debug("Unexpected field Type. Expected: Long, Received: "
 167                                                                                 + fieldObj.getClass().getSimpleName());
 168                                         }
 169                                         return null;
 170                                 }
 171                         }
 172                 }
 173
 174                 if (fieldVal == null) {
 175                         if (TraceDebug.isDEBUG()) {
 176                                 sendNoFieldFoundMsg(fields, expectedFieldName);
 177                         }
 178                 }
 179                 return fieldVal;
 180         }
 181
 182         /**
 183          * protected method used when a Field is requested among several available
 184          * fields and the expected type is String
 185          *
 186          * @param trcEvent
 187          * @param traceSt
 188          * @param expectedNumFields
 189          * @return
 190          */
 191         protected String getAFieldString(LttngEvent trcEvent,
 192                         LttngTraceState traceSt, Fields expectedField) {
 193                 String fieldVal = null;
 194
 195                 TmfEventField[] fields = ((LttngEventContent) trcEvent.getContent())
 196                                 .getFields(trcEvent);
 197
 198                 // Only one field expected
 199                 if (fields.length == 0) {
 200                         TraceDebug.debug("Unexpected number of fields received: "
 201                                         + fields.length);
 202                         return null;
 203                 }
 204
 205                 LttngEventField field;
 206                 String fieldname;
 207                 String expectedFieldName = expectedField.getInName();
 208                 for (int i = 0; i < fields.length; i++) {
 209                         field = (LttngEventField) fields[i];
 210                         fieldname = field.getName();
 211                         if (fieldname.equals(expectedFieldName)) {
 212                                 Object fieldObj = field.getValue();
 213                                 if (fieldObj instanceof String) {
 214                                         // Expected value found
 215                                         fieldVal = (String) field.getValue();
 216                                         break;
 217                                 } else {
 218                                         if (TraceDebug.isDEBUG()) {
 219                                                 TraceDebug
 220                                                                 .debug("Unexpected field Type. Expected: String, Received: "
 221                                                                                 + fieldObj.getClass().getSimpleName());
 222                                         }
 223                                         return null;
 224                                 }
 225                         }
 226                 }
 227
 228                 if (fieldVal == null) {
 229                         if (TraceDebug.isDEBUG()) {
 230                                 sendNoFieldFoundMsg(fields, expectedFieldName);
 231                         }
 232                 }
 233                 return fieldVal;
 234         }
 235
 236         protected void sendNoFieldFoundMsg(TmfEventField[] fields,
 237                         String expectedFieldName) {
 238                 LttngEventField field;
 239                 StringBuilder sb = new StringBuilder("Field not found, requested: "
 240                                 + expectedFieldName);
 241                 sb.append(" number of fields: " + fields.length + "Fields: ");
 242                 for (int i = 0; i < fields.length; i++) {
 243                         field = (LttngEventField) fields[i];
 244                         sb.append(field.getName() + " ");
 245                 }
 246
 247                 TraceDebug.debug(sb.toString(), 5);
 248         }
 249
 250 }