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