org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFStream.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011, 2014 Ericsson, Ecole Polytechnique de Montreal and others
   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: Matthew Khouzam - Initial API and implementation
  10  * Contributors: Simon Marchi - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.ctf.core.trace;
  14
  15 import java.util.HashMap;
  16 import java.util.HashSet;
  17 import java.util.Map;
  18 import java.util.Set;
  19
  20 import org.eclipse.linuxtools.ctf.core.event.IEventDeclaration;
  21 import org.eclipse.linuxtools.ctf.core.event.types.StructDeclaration;
  22 import org.eclipse.linuxtools.internal.ctf.core.event.EventDeclaration;
  23 import org.eclipse.linuxtools.internal.ctf.core.event.metadata.exceptions.ParseException;
  24
  25 /**
  26  * <b><u>Stream</u></b>
  27  * <p>
  28  * Represents a stream in a trace.
  29  * @since 3.0
  30  */
  31 public class CTFStream {
  32
  33     // ------------------------------------------------------------------------
  34     // Attributes
  35     // ------------------------------------------------------------------------
  36
  37
  38     /**
  39      * The numerical ID of the stream
  40      */
  41     private Long fId = null;
  42
  43     /**
  44      * Declarations of the stream-specific structures
  45      */
  46     private StructDeclaration fPacketContextDecl = null;
  47     private StructDeclaration fEventHeaderDecl = null;
  48     private StructDeclaration fEventContextDecl = null;
  49
  50     /**
  51      * The trace to which the stream belongs
  52      */
  53     private CTFTrace fTrace = null;
  54
  55     /**
  56      * Maps event ids to events
  57      */
  58     private Map<Long, IEventDeclaration> fEvents = new HashMap<>();
  59
  60     /**
  61      * The inputs associated to this stream
  62      */
  63     private final Set<CTFStreamInput> fInputs = new HashSet<>();
  64
  65     // ------------------------------------------------------------------------
  66     // Constructors
  67     // ------------------------------------------------------------------------
  68
  69     /**
  70      * Constructs a Stream that belongs to a Trace
  71      *
  72      * @param trace
  73      *            The trace to which belongs this stream.
  74      */
  75     public CTFStream(CTFTrace trace) {
  76         fTrace = trace;
  77     }
  78
  79     // ------------------------------------------------------------------------
  80     // Getters/Setters/Predicates
  81     // ------------------------------------------------------------------------
  82
  83     /**
  84      * Sets the id of a stream
  85      * @param id the id of a stream
  86      */
  87     public void setId(long id) {
  88         fId = id;
  89     }
  90
  91     /**
  92      * Gets the id of a stream
  93      * @return id the id of a stream
  94      */
  95     public Long getId() {
  96         return fId;
  97     }
  98
  99     /**
 100      * Is the id of a stream set
 101      *
 102      * @return If the ID is set or not
 103      */
 104     public boolean isIdSet() {
 105         return fId != null;
 106     }
 107
 108     /**
 109      *
 110      * @return is the event header set (timestamp and stuff) (see Ctf Spec)
 111      */
 112     public boolean isEventHeaderSet() {
 113         return fEventHeaderDecl != null;
 114     }
 115
 116     /**
 117     *
 118     * @return is the event context set (pid and stuff) (see Ctf Spec)
 119     */
 120     public boolean isEventContextSet() {
 121         return fEventContextDecl != null;
 122     }
 123
 124     /**
 125      *
 126      * @return Is the packet context set (see Ctf Spec)
 127      */
 128     public boolean isPacketContextSet() {
 129         return fPacketContextDecl != null;
 130     }
 131
 132     /**
 133      *
 134      * @param eventHeader the current event header for all events in this stream
 135      */
 136     public void setEventHeader(StructDeclaration eventHeader) {
 137         fEventHeaderDecl = eventHeader;
 138     }
 139
 140     /**
 141      *
 142      * @param eventContext the context for all events in this stream
 143      */
 144     public void setEventContext(StructDeclaration eventContext) {
 145         fEventContextDecl = eventContext;
 146     }
 147
 148     /**
 149      *
 150      * @param packetContext the packet context for all packets in this stream
 151      */
 152     public void setPacketContext(StructDeclaration packetContext) {
 153         fPacketContextDecl = packetContext;
 154     }
 155
 156     /**
 157      *
 158      * @return the event header declaration in structdeclaration form
 159      */
 160     public StructDeclaration getEventHeaderDecl() {
 161         return fEventHeaderDecl;
 162     }
 163
 164     /**
 165      *
 166      * @return the event context declaration in structdeclaration form
 167      */
 168     public StructDeclaration getEventContextDecl() {
 169         return fEventContextDecl;
 170     }
 171
 172     /**
 173      *
 174      * @return the packet context declaration in structdeclaration form
 175      */
 176     public StructDeclaration getPacketContextDecl() {
 177         return fPacketContextDecl;
 178     }
 179
 180     /**
 181      *
 182      * @return the set of all stream inputs for this stream
 183      */
 184     public Set<CTFStreamInput> getStreamInputs() {
 185         return fInputs;
 186     }
 187
 188     /**
 189      *
 190      * @return the parent trace
 191      */
 192     public CTFTrace getTrace() {
 193         return fTrace;
 194     }
 195
 196     /**
 197      *
 198      * @return all the event declarations for this stream, using the id as a key for the hashmap.
 199      */
 200     public Map<Long, IEventDeclaration> getEvents() {
 201         return fEvents;
 202     }
 203
 204     // ------------------------------------------------------------------------
 205     // Operations
 206     // ------------------------------------------------------------------------
 207
 208     /**
 209      * Adds an event to the event map.
 210      *
 211      * An event in a stream can omit its id if it is the only event in this
 212      * stream. An event for which no id has been specified has a null id. It is
 213      * thus not possible to add an event with the null key if the map is not
 214      * empty. It is also not possible to add an event to the map if the null key
 215      * is present in the map.
 216      *
 217      * @param event
 218      *            The event to add
 219      * @throws ParseException
 220      *             If there was a problem reading the event or adding it to the
 221      *             stream
 222      */
 223     public void addEvent(IEventDeclaration event) throws ParseException {
 224         /*
 225          * If there is an event without id (the null key), it must be the only
 226          * one
 227          */
 228         if (fEvents.get(null) != null) {
 229             throw new ParseException(
 230                     "Event without id with multiple events in a stream"); //$NON-NLS-1$
 231         }
 232
 233         /*
 234          * If there is an event without id (the null key), it must be the only
 235          * one
 236          */
 237         if ((event.getId() == null) && (fEvents.size() != 0)) {
 238             throw new ParseException(
 239                     "Event without id with multiple events in a stream"); //$NON-NLS-1$
 240         }
 241
 242         /* Check if an event with the same ID already exists */
 243         if (fEvents.get(event.getId()) != null) {
 244             throw new ParseException("Event id already exists"); //$NON-NLS-1$
 245         }
 246         if (event.getId() == null) {
 247             fEvents.put(EventDeclaration.UNSET_EVENT_ID, event);
 248         } else {
 249             /* Put the event in the map */
 250             fEvents.put(event.getId(), event);
 251         }
 252     }
 253
 254     /**
 255      * Add an input to this Stream
 256      *
 257      * @param input
 258      *            The StreamInput to add.
 259      */
 260     public void addInput(CTFStreamInput input) {
 261         fInputs.add(input);
 262     }
 263
 264     @Override
 265     public String toString() {
 266         return "Stream [id=" + fId + ", packetContextDecl=" + fPacketContextDecl //$NON-NLS-1$ //$NON-NLS-2$
 267                 + ", eventHeaderDecl=" + fEventHeaderDecl //$NON-NLS-1$
 268                 + ", eventContextDecl=" + fEventContextDecl + ", trace=" + fTrace //$NON-NLS-1$ //$NON-NLS-2$
 269                 + ", events=" + fEvents + ", inputs=" + fInputs + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 270     }
 271 }