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

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