lttng/org.eclipse.tracecompass.lttng2.control.core/src/org/eclipse/tracecompass/internal/lttng2/control/core/model/impl/ChannelInfo.java

   1 /**********************************************************************
   2  * Copyright (c) 2012, 2015 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  *   Bernd Hufmann - Initial API and implementation
  11  *   Simon Delisle - Updated for support of LTTng Tools 2.2
  12  **********************************************************************/
  13
  14 package org.eclipse.tracecompass.internal.lttng2.control.core.model.impl;
  15
  16 import java.util.ArrayList;
  17 import java.util.Iterator;
  18 import java.util.List;
  19
  20 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IChannelInfo;
  21 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IEventInfo;
  22 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceChannelOutputType;
  23 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceEnablement;
  24
  25 /**
  26  * Implementation of the trace channel interface (IChannelInfo) to store channel
  27  * related data.
  28  *
  29  * @author Bernd Hufmann
  30  */
  31 public class ChannelInfo extends TraceInfo implements IChannelInfo {
  32
  33     // ------------------------------------------------------------------------
  34     // Attributes
  35     // ------------------------------------------------------------------------
  36     /**
  37      * The overwrite mode of the channel.
  38      */
  39     private boolean fOverwriteMode;
  40     /**
  41      * The sub-buffer size of the channel.
  42      */
  43     private long fSubBufferSize;
  44     /**
  45      * The number of sub-buffers of the channel.
  46      */
  47     private int fNumberOfSubBuffers;
  48     /**
  49      * The switch timer interval of the channel.
  50      */
  51     private long fSwitchTimer;
  52     /**
  53      * The read timer interval of the channel.
  54      */
  55     private long fReadTimer;
  56     /**
  57      * The Output type of the channel.
  58      */
  59     private TraceChannelOutputType fOutputType = TraceChannelOutputType.UNKNOWN;
  60     /**
  61      * The channel enable state.
  62      */
  63     private TraceEnablement fState = TraceEnablement.DISABLED;
  64     /**
  65      * The events information of the channel.
  66      */
  67     private final List<IEventInfo> fEvents = new ArrayList<>();
  68     /**
  69      * The maximum size of trace files
  70      */
  71     private long fMaxSizeTraceFiles;
  72     /**
  73      * The maximum number of trace files
  74      */
  75     private int fMaxNumberTraceFiles;
  76     /**
  77      * The value of buffer type
  78      */
  79     private BufferType fBufferType = BufferType.BUFFER_TYPE_UNKNOWN;
  80
  81     // ------------------------------------------------------------------------
  82     // Constructors
  83     // ------------------------------------------------------------------------
  84     /**
  85      * Constructor
  86      *
  87      * @param name
  88      *            - name channel
  89      */
  90     public ChannelInfo(String name) {
  91         super(name);
  92     }
  93
  94     /**
  95      * Copy constructor
  96      *
  97      * @param other
  98      *            - the instance to copy
  99      */
 100     public ChannelInfo(ChannelInfo other) {
 101         super(other);
 102         fOverwriteMode = other.fOverwriteMode;
 103         fSubBufferSize = other.fSubBufferSize;
 104         fNumberOfSubBuffers = other.fNumberOfSubBuffers;
 105         fSwitchTimer = other.fSwitchTimer;
 106         fReadTimer = other.fReadTimer;
 107         fMaxSizeTraceFiles = other.fMaxSizeTraceFiles;
 108         fMaxNumberTraceFiles = other.fMaxNumberTraceFiles;
 109         fBufferType = other.fBufferType;
 110         fOutputType = (other.fOutputType == null ? null : other.fOutputType);
 111         fState = other.fState;
 112         for (Iterator<IEventInfo> iterator = other.fEvents.iterator(); iterator.hasNext();) {
 113             IEventInfo event = iterator.next();
 114             if (event instanceof EventInfo) {
 115                 fEvents.add(new EventInfo((EventInfo) event));
 116             } else {
 117                 fEvents.add(event);
 118             }
 119         }
 120     }
 121
 122     // ------------------------------------------------------------------------
 123     // Accessors
 124     // ------------------------------------------------------------------------
 125
 126     @Override
 127     public boolean isOverwriteMode() {
 128         return fOverwriteMode;
 129     }
 130
 131     @Override
 132     public void setOverwriteMode(boolean mode) {
 133         fOverwriteMode = mode;
 134     }
 135
 136     @Override
 137     public long getSubBufferSize() {
 138         return fSubBufferSize;
 139     }
 140
 141     @Override
 142     public void setSubBufferSize(long bufferSize) {
 143         fSubBufferSize = bufferSize;
 144     }
 145
 146     @Override
 147     public int getNumberOfSubBuffers() {
 148         return fNumberOfSubBuffers;
 149     }
 150
 151     @Override
 152     public void setNumberOfSubBuffers(int numberOfSubBuffers) {
 153         fNumberOfSubBuffers = numberOfSubBuffers;
 154     }
 155
 156     @Override
 157     public long getSwitchTimer() {
 158         return fSwitchTimer;
 159     }
 160
 161     @Override
 162     public void setSwitchTimer(long timer) {
 163         fSwitchTimer = timer;
 164     }
 165
 166     @Override
 167     public long getReadTimer() {
 168         return fReadTimer;
 169     }
 170
 171     @Override
 172     public void setReadTimer(long timer) {
 173         fReadTimer = timer;
 174     }
 175
 176     @Override
 177     public TraceChannelOutputType getOutputType() {
 178         return fOutputType;
 179     }
 180
 181     @Override
 182     public void setOutputType(String type) {
 183         fOutputType = TraceChannelOutputType.valueOfString(type);
 184     }
 185
 186     @Override
 187     public void setOutputType(TraceChannelOutputType type) {
 188         fOutputType = type;
 189     }
 190
 191     @Override
 192     public TraceEnablement getState() {
 193         return fState;
 194     }
 195
 196     @Override
 197     public void setState(TraceEnablement state) {
 198         fState = state;
 199     }
 200
 201     @Override
 202     public void setState(String stateName) {
 203         fState = TraceEnablement.valueOfString(stateName);
 204     }
 205
 206     @Override
 207     public IEventInfo[] getEvents() {
 208         return fEvents.toArray(new IEventInfo[fEvents.size()]);
 209     }
 210
 211     @Override
 212     public void setEvents(List<IEventInfo> events) {
 213         fEvents.clear();
 214         for (Iterator<IEventInfo> iterator = events.iterator(); iterator.hasNext();) {
 215             IEventInfo eventInfo = iterator.next();
 216             fEvents.add(eventInfo);
 217         }
 218     }
 219
 220     @Override
 221     public void addEvent(IEventInfo channel) {
 222         fEvents.add(channel);
 223     }
 224
 225     @Override
 226     public int hashCode() {
 227         final int prime = 31;
 228         int result = super.hashCode();
 229         result = prime * result + fEvents.hashCode();
 230         result = prime * result + fNumberOfSubBuffers;
 231         result = prime * result + ((fOutputType == null) ? 0 : fOutputType.hashCode());
 232         result = prime * result + (fOverwriteMode ? 1231 : 1237);
 233         result = prime * result + (int) (fReadTimer ^ (fReadTimer >>> 32));
 234         result = prime * result + ((fState == null) ? 0 : (fState.ordinal() + 1));
 235         result = prime * result + (int) (fSubBufferSize ^ (fSubBufferSize >>> 32));
 236         result = prime * result + (int) (fSwitchTimer ^ (fSwitchTimer >>> 32));
 237         result = prime * result + ((fBufferType == null) ? 0 : (fBufferType.ordinal() + 1));
 238         return result;
 239     }
 240
 241     @Override
 242     public boolean equals(Object obj) {
 243         if (this == obj) {
 244             return true;
 245         }
 246         if (!super.equals(obj)) {
 247             return false;
 248         }
 249         if (getClass() != obj.getClass()) {
 250             return false;
 251         }
 252         ChannelInfo other = (ChannelInfo) obj;
 253         if (!fEvents.equals(other.fEvents)) {
 254             return false;
 255         }
 256         if (fNumberOfSubBuffers != other.fNumberOfSubBuffers) {
 257             return false;
 258         }
 259         if (fOutputType == null) {
 260             if (other.fOutputType != null) {
 261                 return false;
 262             }
 263         } else if (!fOutputType.equals(other.fOutputType)) {
 264             return false;
 265         }
 266         if (fOverwriteMode != other.fOverwriteMode) {
 267             return false;
 268         }
 269         if (fReadTimer != other.fReadTimer) {
 270             return false;
 271         }
 272         if (fState != other.fState) {
 273             return false;
 274         }
 275         if (fSubBufferSize != other.fSubBufferSize) {
 276             return false;
 277         }
 278         if (fSwitchTimer != other.fSwitchTimer) {
 279             return false;
 280         }
 281         if (fBufferType != other.fBufferType) {
 282             return false;
 283         }
 284         return true;
 285     }
 286
 287     @SuppressWarnings("nls")
 288     @Override
 289     public String toString() {
 290         StringBuffer output = new StringBuffer();
 291         output.append("[ChannelInfo(");
 292         output.append(super.toString());
 293         output.append(",State=");
 294         output.append(fState);
 295         output.append(",OverwriteMode=");
 296         output.append(fOverwriteMode);
 297         output.append(",SubBuffersSize=");
 298         output.append(fSubBufferSize);
 299         output.append(",NumberOfSubBuffers=");
 300         output.append(fNumberOfSubBuffers);
 301         output.append(",SwitchTimer=");
 302         output.append(fSwitchTimer);
 303         output.append(",ReadTimer=");
 304         output.append(fReadTimer);
 305         output.append(",output=");
 306         output.append(fOutputType.getInName());
 307         if ((fBufferType != null) && !fBufferType.equals(BufferType.BUFFER_TYPE_UNKNOWN) && !fBufferType.equals(BufferType.BUFFER_SHARED)) {
 308             output.append(",BufferType=");
 309             output.append(fBufferType);
 310         }
 311         output.append(",Events=");
 312         if (fEvents.isEmpty()) {
 313             output.append("None");
 314         } else {
 315             for (Iterator<IEventInfo> iterator = fEvents.iterator(); iterator.hasNext();) {
 316                 IEventInfo event = iterator.next();
 317                 output.append(event.toString());
 318             }
 319         }
 320         output.append(")]");
 321         return output.toString();
 322     }
 323
 324     @Override
 325     public void setMaxSizeTraceFiles(long maxSizeTraceFiles) {
 326         fMaxSizeTraceFiles = maxSizeTraceFiles;
 327     }
 328
 329     @Override
 330     public void setMaxNumberTraceFiles(int maxNumberTraceFiles) {
 331         fMaxNumberTraceFiles = maxNumberTraceFiles;
 332     }
 333
 334     @Override
 335     public long getMaxSizeTraceFiles() {
 336         return fMaxSizeTraceFiles;
 337     }
 338
 339     @Override
 340     public int getMaxNumberTraceFiles() {
 341         return fMaxNumberTraceFiles;
 342     }
 343
 344     @Override
 345     public void setBufferType(BufferType bufferType) {
 346         fBufferType = bufferType;
 347     }
 348
 349     @Override
 350     public BufferType getBufferType() {
 351         return fBufferType;
 352     }
 353 }