org.eclipse.linuxtools.lttng.core/src/org/eclipse/linuxtools/lttng/core/event/LttngEventContent.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   William Bourque (wbourque@gmail.com) - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.lttng.core.event;
  14
  15 import java.util.HashMap;
  16
  17 import org.eclipse.linuxtools.lttng.jni.JniEvent;
  18 import org.eclipse.linuxtools.tmf.core.event.TmfEventContent;
  19 import org.eclipse.linuxtools.tmf.core.event.TmfNoSuchFieldException;
  20
  21 /**
  22  * <b><u>LttngEventContent</u></b><p>
  23  *
  24  * Lttng specific implementation of the TmfEventContent.<p>
  25  */
  26 public class LttngEventContent extends TmfEventContent {
  27
  28     // Hash map that contain the (parsed) fields. This is the actual payload of the event.
  29     HashMap<String, LttngEventField> fFieldsMap = new HashMap<String, LttngEventField>();
  30
  31     /**
  32      * Default constructor.<p>
  33      *
  34      *
  35      */
  36     public LttngEventContent() {
  37         super(null, null);
  38     }
  39
  40     /**
  41      * Constructor with parameters.<p>
  42      *
  43      * @param thisParent    Parent event for this content.
  44      *
  45      * @see org.eclipse.linuxtools.lttng.core.event.LttngEvent
  46      */
  47     public LttngEventContent(LttngEvent thisParent) {
  48         super(thisParent, null);
  49     }
  50
  51     /**
  52      * Constructor with parameters, with optional content.<p>
  53      *
  54      * @param thisParent    Parent event for this content.
  55      * @param thisContent   Already parsed content.
  56      *
  57      * @see org.eclipse.linuxtools.lttng.core.event.LttngEvent
  58      */
  59     public LttngEventContent(LttngEvent thisParent, HashMap<String, LttngEventField> thisContent) {
  60         super(thisParent, null);
  61
  62         fFieldsMap = thisContent;
  63     }
  64
  65     /**
  66      * Copy Constructor.<p>
  67      *
  68      * @param oldContent  Content to copy from
  69      */
  70     public LttngEventContent(LttngEventContent oldContent) {
  71         this((LttngEvent)oldContent.getEvent(), oldContent.getRawContent() );
  72     }
  73
  74
  75     @Override
  76         public LttngEvent getEvent() {
  77         return (LttngEvent)fParentEvent;
  78     }
  79
  80     public void setEvent(LttngEvent newParent) {
  81         fParentEvent = newParent;
  82     }
  83
  84
  85     // *** VERIFY ***
  86     // These are not very useful, are they?
  87     @Override
  88         public LttngEventType getType() {
  89         return (LttngEventType)fParentEvent.getType();
  90     }
  91     public void setType(LttngEventType newType) {
  92         ((LttngEvent)fParentEvent).setType(newType);
  93     }
  94
  95
  96     // ***TODO***
  97     // Find a better way to ensure content is sane!!
  98     public void emptyContent() {
  99         fFieldsMap.clear();
 100     }
 101
 102     // ***VERIFY***
 103     // A bit weird to return the _currently_parsed fields (unlike all fields like getFields() )
 104     // Should we keep this?
 105     /**
 106      * Return currently parsed fields in an object array format.<p>
 107      *
 108      * @return  Currently parsed fields.
 109      */
 110     @Override
 111     public Object[] getContent() {
 112         Object[] returnedContent = fFieldsMap.values().toArray( new Object[fFieldsMap.size()] );
 113
 114         return returnedContent;
 115     }
 116
 117     /**
 118      * Return currently parsed fields in the internal hashmap format.<p>
 119      *
 120      * @return  Currently parsed fields.
 121      */
 122     public HashMap<String, LttngEventField> getRawContent() {
 123         return fFieldsMap;
 124     }
 125
 126 //    @SuppressWarnings("unchecked")
 127 //    @Override
 128 //    public LttngEventField[] getFields() {
 129 //        LttngEventField tmpField = null;
 130 //
 131 //        // *** TODO ***
 132 //        // SLOW! SLOW! SLOW! We should prevent the user to use this!!
 133 //        HashMap<String, Object> parsedContent = parseContent();
 134 //
 135 //        String contentKey = null;
 136 //        Iterator<String> contentItr = parsedContent.keySet().iterator();
 137 //        while ( contentItr.hasNext() ) {
 138 //            contentKey = contentItr.next();
 139 //
 140 //            tmpField = new LttngEventField(this, contentKey, parsedContent.get(contentKey));
 141 //            ((HashMap<String, LttngEventField>)fFields).put(contentKey, tmpField);
 142 //        }
 143 //
 144 //        return fFields.values().toArray(new LttngEventField[fFields.size()]);
 145 //    }
 146
 147     /**
 148      * Parse all fields and return them as an array of LttngFields.<p>
 149      *
 150      * Note : This function is heavy and should only be called if all fields are really needed.
 151      *
 152      * @return  All fields.
 153      *
 154      * @see @see org.eclipse.linuxtools.lttng.event.LttngEventField
 155      */
 156     @Override
 157     public synchronized LttngEventField[] getFields() {
 158         if ( fFieldsMap.size() < fParentEvent.getType().getNbFields() ) {
 159                 LttngEventField tmpField = null;
 160                 LttngEventType tmpType = (LttngEventType)fParentEvent.getType();
 161
 162                 for ( int pos=0; pos<tmpType.getNbFields(); pos++ ) {
 163                     String name = null;
 164                     LttngEvent lttngTmpEvent = (LttngEvent)getEvent(); //added for easier debugging
 165                                 JniEvent tmpEvent = (lttngTmpEvent).convertEventTmfToJni();
 166
 167                                 // tmpEvent == null probably mean there is a discrepancy between Eclipse and C library
 168                                 // An error was probably printed in convertEventTmfToJni() already, but keep in mind this is SERIOUS
 169                                 if ( tmpEvent != null ) {
 170                                         try {
 171                                                 name = tmpType.getLabel(pos);
 172
 173                                                 Object newValue = tmpEvent.parseFieldByName(name);
 174                                                 tmpField = new LttngEventField(this, name, newValue );
 175                                                 fFieldsMap.put(name, tmpField);
 176                                         }
 177                                         catch (TmfNoSuchFieldException e) {
 178                                                 System.out.println("Invalid field position requested : " + pos + ", ignoring (getFields).");  //$NON-NLS-1$//$NON-NLS-2$
 179                                         }
 180                     }
 181                 }
 182         }
 183         return fFieldsMap.values().toArray(new LttngEventField[fFieldsMap.size()]);
 184     }
 185
 186     /**
 187      * Parse a single field from its given position.<p>
 188      *
 189      * @return  The parsed field or null.
 190      *
 191      * @see @see org.eclipse.linuxtools.lttng.event.LttngEventField
 192      */
 193     @Override
 194     public LttngEventField getField(int position) {
 195         LttngEventField returnedField = null;
 196         String label = null;
 197                 try {
 198                         label = fParentEvent.getType().getLabel(position);
 199
 200                         returnedField = (LttngEventField) this.getField(label);
 201                 }
 202                 catch (TmfNoSuchFieldException e) {
 203                         System.out.println("Invalid field position requested : " + position + ", ignoring (getField).");  //$NON-NLS-1$//$NON-NLS-2$
 204                 }
 205
 206         return returnedField;
 207     }
 208
 209     /**
 210      * Parse a single field from its given name.<p>
 211      *
 212      * @return  The parsed field or null.
 213      *
 214      * @see @see org.eclipse.linuxtools.lttng.event.LttngEventField
 215      */
 216     @Override
 217     public synchronized Object getField(String name) {
 218
 219         // Check for generic table header fields
 220         if (name.equals(LttngEventType.CONTENT_LABEL) || name.equals(FIELD_ID_CONTENT)) {
 221             return fParentEvent.getContent().toString();
 222         } else if (name.equals(LttngEventType.MARKER_LABEL) || name.equals(FIELD_ID_TYPE)) {
 223             return fParentEvent.getType().getTypeId().toString();
 224         } else if (name.equals(LttngEventType.TRACE_LABEL) || name.equals(FIELD_ID_REFERENCE)) {
 225             return fParentEvent.getReference().getReference().toString();
 226         } else if (name.equals(LttngEventType.TIMESTAMP_LABEL) || name.equals(FIELD_ID_TIMESTAMP)) {
 227             return new Long(fParentEvent.getTimestamp().getValue()).toString();
 228         } else if (name.equals(FIELD_ID_SOURCE)) {
 229             return fParentEvent.getSource().getSourceId().toString();
 230         }
 231
 232         // *** VERIFY ***
 233         // Should we check if the field exists in LttngType before parsing?
 234         // It could avoid calling parse for non-existent fields but would waste some cpu cycle on check?
 235         LttngEventField returnedField = fFieldsMap.get(name);
 236
 237         if ( returnedField == null ) {
 238             // *** VERIFY ***
 239             // Should we really make sure we didn't get null before creating/inserting a field?
 240                 JniEvent tmpEvent = ((LttngEvent)getEvent()).convertEventTmfToJni();
 241
 242                 if ( tmpEvent != null) {
 243                         Object newValue =  tmpEvent.parseFieldByName(name);
 244
 245                     if ( newValue!= null ) {
 246                         returnedField = new LttngEventField(this, name, newValue);
 247                         fFieldsMap.put(name, returnedField );
 248                     }
 249                 }
 250         }
 251
 252         return returnedField;
 253     }
 254
 255     // *** VERIFY ***
 256     // *** Is this even useful?
 257     @Override
 258     protected void parseContent() {
 259         fFields = getFields();
 260     }
 261
 262     /**
 263      * toString() method to print the content
 264      *
 265      * Note : this function parse all fields and so is very heavy to use.
 266      */
 267     @Override
 268     @SuppressWarnings("nls")
 269     public String toString() {
 270         LttngEventField[] allFields = getFields();
 271
 272         StringBuffer strBuffer = new StringBuffer();
 273         for ( int pos=0; pos < allFields.length; pos++) {
 274                 if (pos != 0) strBuffer.append(",");
 275                 strBuffer.append(allFields[pos].toString());
 276         }
 277
 278         return strBuffer.toString();
 279     }
 280
 281         @Override
 282         public LttngEventContent clone() {
 283                 LttngEventContent clone = (LttngEventContent) super.clone();
 284                 LttngEventField[] fields = getFields();
 285                 clone.fFields = new LttngEventField[fields.length];
 286                 for (int i = 0; i < fields.length; i++) {
 287                         clone.fFields[i] = fields[i].clone();
 288                 }
 289                 clone.fFieldsMap = new HashMap<String, LttngEventField>();
 290                 for (String key : fFieldsMap.keySet()) {
 291                         clone.fFieldsMap.put(new String(key), ((LttngEventField) fFieldsMap.get(key)).clone());
 292                 }
 293                 return clone;
 294         }
 295
 296 }