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

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