From: Matthew Khouzam Date: Fri, 14 Feb 2014 16:55:04 +0000 (-0500) Subject: ctf: minor code style cleanup X-Git-Url: http://drtracing.org/?a=commitdiff_plain;h=93a45b54beab05dd69db4686210e3fb35d150284;p=deliverable%2Ftracecompass.git ctf: minor code style cleanup Changed fields to start with f, removing the need for so many this pointers. Change-Id: Ibff3a4de733fa1c2eeb49a3b8b8baa0654fe7136 Signed-off-by: Matthew Khouzam Reviewed-on: https://git.eclipse.org/r/22023 Tested-by: Hudson CI Reviewed-by: Marc-Andre Laperle IP-Clean: Marc-Andre Laperle Tested-by: Marc-Andre Laperle --- diff --git a/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFTraceReader.java b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFTraceReader.java index 0485380c58..44a47baaaf 100644 --- a/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFTraceReader.java +++ b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFTraceReader.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2011, 2013 Ericsson, Ecole Polytechnique de Montreal and others + * Copyright (c) 2011, 2014 Ericsson, Ecole Polytechnique de Montreal and others * * All rights reserved. This program and the accompanying materials are made * available under the terms of the Eclipse Public License v1.0 which @@ -38,32 +38,32 @@ public class CTFTraceReader { /** * The trace to read from. */ - private final CTFTrace trace; + private final CTFTrace fTrace; /** * Vector of all the trace file readers. */ - private final List streamInputReaders = new ArrayList<>(); + private final List fStreamInputReaders = new ArrayList<>(); /** * Priority queue to order the trace file readers by timestamp. */ - private PriorityQueue prio; + private PriorityQueue fPrio; /** * Array to count the number of event per trace file. */ - private long[] eventCountPerTraceFile; + private long[] fEventCountPerTraceFile; /** * Timestamp of the first event in the trace */ - private long startTime; + private long fStartTime; /** * Timestamp of the last event read so far */ - private long endTime; + private long fEndTime; // ------------------------------------------------------------------------ // Constructors @@ -78,8 +78,8 @@ public class CTFTraceReader { * if an error occurs */ public CTFTraceReader(CTFTrace trace) throws CTFReaderException { - this.trace = trace; - streamInputReaders.clear(); + fTrace = trace; + fStreamInputReaders.clear(); /** * Create the trace file readers. @@ -95,10 +95,10 @@ public class CTFTraceReader { * Get the start Time of this trace bear in mind that the trace could be * empty. */ - this.startTime = 0; + fStartTime = 0; if (hasMoreEvents()) { - this.startTime = prio.peek().getCurrentEvent().getTimestamp(); - this.setEndTime(this.startTime); + fStartTime = fPrio.peek().getCurrentEvent().getTimestamp(); + setEndTime(fStartTime); } } @@ -111,9 +111,9 @@ public class CTFTraceReader { public CTFTraceReader copyFrom() throws CTFReaderException { CTFTraceReader newReader = null; - newReader = new CTFTraceReader(this.trace); - newReader.startTime = this.startTime; - newReader.setEndTime(this.endTime); + newReader = new CTFTraceReader(fTrace); + newReader.fStartTime = fStartTime; + newReader.setEndTime(fEndTime); return newReader; } @@ -123,12 +123,12 @@ public class CTFTraceReader { * @since 2.0 */ public void dispose() { - for (StreamInputReader reader : streamInputReaders) { + for (StreamInputReader reader : fStreamInputReaders) { if (reader != null) { reader.dispose(); } } - streamInputReaders.clear(); + fStreamInputReaders.clear(); } // ------------------------------------------------------------------------ @@ -141,7 +141,7 @@ public class CTFTraceReader { * @return the trace start time */ public long getStartTime() { - return this.startTime; + return fStartTime; } /** @@ -151,7 +151,7 @@ public class CTFTraceReader { * The end time to use */ protected final void setEndTime(long endTime) { - this.endTime = endTime; + fEndTime = endTime; } /** @@ -161,7 +161,7 @@ public class CTFTraceReader { * @since 2.0 */ protected PriorityQueue getPrio() { - return prio; + return fPrio; } // ------------------------------------------------------------------------ @@ -178,7 +178,7 @@ public class CTFTraceReader { /* * For each stream. */ - for (Stream stream : this.trace.getStreams()) { + for (Stream stream : fTrace.getStreams()) { Set streamInputs = stream.getStreamInputs(); /* @@ -194,14 +194,14 @@ public class CTFTraceReader { /* * Add it to the group. */ - this.streamInputReaders.add(streamInputReader); + fStreamInputReaders.add(streamInputReader); } } /* * Create the array to count the number of event per trace file. */ - this.eventCountPerTraceFile = new long[this.streamInputReaders.size()]; + fEventCountPerTraceFile = new long[fStreamInputReaders.size()]; } /** @@ -212,8 +212,8 @@ public class CTFTraceReader { * if an error occurs */ private void populateStreamInputReaderHeap() throws CTFReaderException { - if (this.streamInputReaders.isEmpty()) { - this.prio = new PriorityQueue<>(); + if (fStreamInputReaders.isEmpty()) { + fPrio = new PriorityQueue<>(); return; } @@ -221,22 +221,22 @@ public class CTFTraceReader { * Create the priority queue with a size twice as bigger as the number * of reader in order to avoid constant resizing. */ - this.prio = new PriorityQueue<>( - this.streamInputReaders.size() * 2, + fPrio = new PriorityQueue<>( + fStreamInputReaders.size() * 2, new StreamInputReaderTimestampComparator()); int pos = 0; - for (StreamInputReader reader : this.streamInputReaders) { + for (StreamInputReader reader : fStreamInputReaders) { /* * Add each trace file reader in the priority queue, if we are able * to read an event from it. */ reader.setParent(this); if (reader.readNextEvent()) { - this.prio.add(reader); + fPrio.add(reader); - this.eventCountPerTraceFile[pos] = 0; + fEventCountPerTraceFile[pos] = 0; reader.setName(pos); pos++; @@ -268,7 +268,7 @@ public class CTFTraceReader { /* * Remove the reader from the top of the priority queue. */ - StreamInputReader top = this.prio.poll(); + StreamInputReader top = fPrio.poll(); /* * If the queue was empty. @@ -283,14 +283,14 @@ public class CTFTraceReader { /* * Add it back in the queue. */ - this.prio.add(top); - final long topEnd = this.trace.timestampCyclesToNanos(top.getCurrentEvent().getTimestamp()); - this.setEndTime(Math.max(topEnd, this.getEndTime())); - this.eventCountPerTraceFile[top.getName()]++; + fPrio.add(top); + final long topEnd = fTrace.timestampCyclesToNanos(top.getCurrentEvent().getTimestamp()); + setEndTime(Math.max(topEnd, getEndTime())); + fEventCountPerTraceFile[top.getName()]++; if (top.getCurrentEvent() != null) { - this.endTime = Math.max(top.getCurrentEvent().getTimestamp(), - this.endTime); + fEndTime = Math.max(top.getCurrentEvent().getTimestamp(), + fEndTime); } } /* @@ -307,9 +307,9 @@ public class CTFTraceReader { * if an error occurs */ public void goToLastEvent() throws CTFReaderException { - seek(this.getEndTime()); - while (this.prio.size() > 1) { - this.advance(); + seek(getEndTime()); + while (fPrio.size() > 1) { + advance(); } } @@ -331,8 +331,8 @@ public class CTFTraceReader { /* * Remove all the trace readers from the priority queue */ - this.prio.clear(); - for (StreamInputReader streamInputReader : this.streamInputReaders) { + fPrio.clear(); + for (StreamInputReader streamInputReader : fStreamInputReaders) { /* * Seek the trace reader. */ @@ -342,7 +342,7 @@ public class CTFTraceReader { * Add it to the priority queue if there is a current event. */ if (streamInputReader.getCurrentEvent() != null) { - this.prio.add(streamInputReader); + fPrio.add(streamInputReader); } } return hasMoreEvents(); @@ -354,7 +354,7 @@ public class CTFTraceReader { * @return the stream with the oldest event */ public StreamInputReader getTopStream() { - return this.prio.peek(); + return fPrio.peek(); } /** @@ -363,7 +363,7 @@ public class CTFTraceReader { * @return true if yes. */ public final boolean hasMoreEvents() { - return this.prio.size() > 0; + return fPrio.size() > 0; } /** @@ -385,14 +385,14 @@ public class CTFTraceReader { return; } - for (long i : this.eventCountPerTraceFile) { + for (long i : fEventCountPerTraceFile) { numEvents += i; } - for (int j = 0; j < this.eventCountPerTraceFile.length; j++) { - StreamInputReader se = this.streamInputReaders.get(j); + for (int j = 0; j < fEventCountPerTraceFile.length; j++) { + StreamInputReader se = fStreamInputReaders.get(j); - long len = (width * this.eventCountPerTraceFile[se.getName()]) + long len = (width * fEventCountPerTraceFile[se.getName()]) / numEvents; StringBuilder sb = new StringBuilder(se.getFilename()); @@ -406,7 +406,7 @@ public class CTFTraceReader { sb.append(' '); } - sb.append("]\t" + this.eventCountPerTraceFile[se.getName()] + " Events"); //$NON-NLS-1$//$NON-NLS-2$ + sb.append("]\t" + fEventCountPerTraceFile[se.getName()] + " Events"); //$NON-NLS-1$//$NON-NLS-2$ Activator.log(sb.toString()); } } @@ -418,16 +418,16 @@ public class CTFTraceReader { * @return the last event */ public long getEndTime() { - return this.endTime; + return fEndTime; } @Override public int hashCode() { final int prime = 31; int result = 1; - result = (prime * result) + (int) (startTime ^ (startTime >>> 32)); - result = (prime * result) + streamInputReaders.hashCode(); - result = (prime * result) + ((trace == null) ? 0 : trace.hashCode()); + result = (prime * result) + (int) (fStartTime ^ (fStartTime >>> 32)); + result = (prime * result) + fStreamInputReaders.hashCode(); + result = (prime * result) + ((fTrace == null) ? 0 : fTrace.hashCode()); return result; } @@ -443,14 +443,14 @@ public class CTFTraceReader { return false; } CTFTraceReader other = (CTFTraceReader) obj; - if (!streamInputReaders.equals(other.streamInputReaders)) { + if (!fStreamInputReaders.equals(other.fStreamInputReaders)) { return false; } - if (trace == null) { - if (other.trace != null) { + if (fTrace == null) { + if (other.fTrace != null) { return false; } - } else if (!trace.equals(other.trace)) { + } else if (!fTrace.equals(other.fTrace)) { return false; } return true; @@ -459,7 +459,7 @@ public class CTFTraceReader { @Override public String toString() { /* Only for debugging, shouldn't be externalized */ - return "CTFTraceReader [trace=" + trace + ']'; //$NON-NLS-1$ + return "CTFTraceReader [trace=" + fTrace + ']'; //$NON-NLS-1$ } /** @@ -468,6 +468,6 @@ public class CTFTraceReader { * @return the parent trace */ public CTFTrace getTrace() { - return trace; + return fTrace; } } diff --git a/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/StreamInputReader.java b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/StreamInputReader.java index a2107b6517..9ea692ff7d 100644 --- a/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/StreamInputReader.java +++ b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/StreamInputReader.java @@ -37,30 +37,30 @@ public class StreamInputReader { /** * The StreamInput we are reading. */ - private final StreamInput streamInput; + private final StreamInput fStreamInput; /** * The packet reader used to read packets from this trace file. */ - private final StreamInputPacketReader packetReader; + private final StreamInputPacketReader fPacketReader; /** * Iterator on the packet index */ - private int packetIndex; + private int fPacketIndex; /** * Reference to the current event of this trace file (iow, the last on that * was read, the next one to be returned) */ - private EventDefinition currentEvent = null; + private EventDefinition fCurrentEvent = null; - private int name; + private int fId; - private CTFTraceReader parent; + private CTFTraceReader fParent; /** Map of all the event types */ - private final Map eventDefs = new HashMap<>(); + private final Map fEventDefs = new HashMap<>(); // ------------------------------------------------------------------------ // Constructors @@ -76,12 +76,12 @@ public class StreamInputReader { * @since 2.0 */ public StreamInputReader(StreamInput streamInput) throws CTFReaderException { - this.streamInput = streamInput; - this.packetReader = new StreamInputPacketReader(this); + fStreamInput = streamInput; + fPacketReader = new StreamInputPacketReader(this); /* * Get the iterator on the packet index. */ - this.packetIndex = 0; + fPacketIndex = 0; /* * Make first packet the current one. */ @@ -94,7 +94,7 @@ public class StreamInputReader { * @since 2.0 */ public void dispose() { - packetReader.dispose(); + fPacketReader.dispose(); } // ------------------------------------------------------------------------ @@ -108,7 +108,7 @@ public class StreamInputReader { * finished/empty/malformed */ public EventDefinition getCurrentEvent() { - return this.currentEvent; + return fCurrentEvent; } /** @@ -117,7 +117,7 @@ public class StreamInputReader { * @return the current packet context (size, lost events and such) */ public StructDefinition getCurrentPacketContext() { - return this.packetReader.getStreamPacketContextDef(); + return fPacketReader.getStreamPacketContextDef(); } /** @@ -126,7 +126,7 @@ public class StreamInputReader { * @return the trace byte order */ public ByteOrder getByteOrder() { - return streamInput.getStream().getTrace().getByteOrder(); + return fStreamInput.getStream().getTrace().getByteOrder(); } /** @@ -135,7 +135,7 @@ public class StreamInputReader { * @return gets the stream name (it's a number) */ public int getName() { - return this.name; + return fId; } /** @@ -145,7 +145,7 @@ public class StreamInputReader { * the name of the stream, (it's a number) */ public void setName(int name) { - this.name = name; + fId = name; } /** @@ -155,7 +155,7 @@ public class StreamInputReader { * @return The CPU id (a number) */ public int getCPU() { - return this.packetReader.getCPU(); + return fPacketReader.getCPU(); } /** @@ -164,14 +164,14 @@ public class StreamInputReader { * @return The filename of the stream being read */ public String getFilename() { - return streamInput.getFilename(); + return fStreamInput.getFilename(); } /* * for internal use only */ StreamInput getStreamInput() { - return streamInput; + return fStreamInput; } /** @@ -181,7 +181,7 @@ public class StreamInputReader { * @since 2.1 */ public Map getEventDefinitions() { - return Collections.unmodifiableMap(eventDefs); + return Collections.unmodifiableMap(fEventDefs); } /** @@ -195,7 +195,7 @@ public class StreamInputReader { * @since 2.1 */ public void addEventDefinition(Long id, EventDefinition def) { - eventDefs.put(id, def); + fEventDefs.put(id, def); } // ------------------------------------------------------------------------ @@ -213,8 +213,8 @@ public class StreamInputReader { /* * Change packet if needed */ - if (!this.packetReader.hasMoreEvents()) { - final StreamInputPacketIndexEntry prevPacket = this.packetReader + if (!fPacketReader.hasMoreEvents()) { + final StreamInputPacketIndexEntry prevPacket = fPacketReader .getCurrentPacket(); if (prevPacket != null) { goToNextPacket(); @@ -224,8 +224,8 @@ public class StreamInputReader { /* * If an event is available, read it. */ - if (this.packetReader.hasMoreEvents()) { - this.setCurrentEvent(this.packetReader.readNextEvent()); + if (fPacketReader.hasMoreEvents()) { + this.setCurrentEvent(fPacketReader.readNextEvent()); return true; } this.setCurrentEvent(null); @@ -239,15 +239,15 @@ public class StreamInputReader { * if an error occurs */ private void goToNextPacket() throws CTFReaderException { - packetIndex++; - if (getPacketSize() >= (packetIndex + 1)) { - this.packetReader.setCurrentPacket(getPacket()); + fPacketIndex++; + if (getPacketSize() >= (fPacketIndex + 1)) { + fPacketReader.setCurrentPacket(getPacket()); } else { - if (this.streamInput.addPacketHeaderIndex()) { - packetIndex = getPacketSize() - 1; - this.packetReader.setCurrentPacket(getPacket()); + if (fStreamInput.addPacketHeaderIndex()) { + fPacketIndex = getPacketSize() - 1; + fPacketReader.setCurrentPacket(getPacket()); } else { - this.packetReader.setCurrentPacket(null); + fPacketReader.setCurrentPacket(null); } } } @@ -256,7 +256,7 @@ public class StreamInputReader { * @return */ private int getPacketSize() { - return streamInput.getIndex().getEntries().size(); + return fStreamInput.getIndex().getEntries().size(); } /** @@ -277,16 +277,16 @@ public class StreamInputReader { /* * index up to the desired timestamp. */ - while ((this.packetReader.getCurrentPacket() != null) - && (this.packetReader.getCurrentPacket().getTimestampEnd() < timestamp)) { + while ((fPacketReader.getCurrentPacket() != null) + && (fPacketReader.getCurrentPacket().getTimestampEnd() < timestamp)) { try { - this.streamInput.addPacketHeaderIndex(); + fStreamInput.addPacketHeaderIndex(); goToNextPacket(); } catch (CTFReaderException e) { // do nothing here } } - if (this.packetReader.getCurrentPacket() == null) { + if (fPacketReader.getCurrentPacket() == null) { gotoPacket(timestamp); } @@ -313,7 +313,7 @@ public class StreamInputReader { * if an error occurs */ private void gotoPacket(long timestamp) throws CTFReaderException { - this.packetIndex = this.streamInput.getIndex().search(timestamp) + fPacketIndex = fStreamInput.getIndex().search(timestamp) .previousIndex(); /* * Switch to this packet. @@ -331,7 +331,7 @@ public class StreamInputReader { /* * Search in the index for the packet to search in. */ - final int len = this.streamInput.getIndex().getEntries().size(); + final int len = fStreamInput.getIndex().getEntries().size(); /* * Go to beginning of trace. @@ -340,7 +340,7 @@ public class StreamInputReader { /* * if the trace is empty. */ - if ((len == 0) || (this.packetReader.hasMoreEvents() == false)) { + if ((len == 0) || (fPacketReader.hasMoreEvents() == false)) { /* * This means the trace is empty. abort. */ @@ -350,9 +350,9 @@ public class StreamInputReader { * Go to the last packet that contains events. */ for (int pos = len - 1; pos > 0; pos--) { - packetIndex = pos; - this.packetReader.setCurrentPacket(getPacket()); - if (this.packetReader.hasMoreEvents()) { + fPacketIndex = pos; + fPacketReader.setCurrentPacket(getPacket()); + if (fPacketReader.hasMoreEvents()) { break; } } @@ -361,8 +361,8 @@ public class StreamInputReader { * Go until the end of that packet */ EventDefinition prevEvent = null; - while (this.currentEvent != null) { - prevEvent = this.currentEvent; + while (fCurrentEvent != null) { + prevEvent = fCurrentEvent; this.readNextEvent(); } /* @@ -375,7 +375,7 @@ public class StreamInputReader { * @return the parent */ public CTFTraceReader getParent() { - return parent; + return fParent; } /** @@ -383,7 +383,7 @@ public class StreamInputReader { * the parent to set */ public void setParent(CTFTraceReader parent) { - this.parent = parent; + fParent = parent; } /** @@ -393,34 +393,34 @@ public class StreamInputReader { * the event to set */ public void setCurrentEvent(EventDefinition currentEvent) { - this.currentEvent = currentEvent; + fCurrentEvent = currentEvent; } /** * @return the packetIndexIt */ private int getPacketIndex() { - return packetIndex; + return fPacketIndex; } private StreamInputPacketIndexEntry getPacket() { - return streamInput.getIndex().getEntries().get(getPacketIndex()); + return fStreamInput.getIndex().getEntries().get(getPacketIndex()); } /** * @return the packetReader */ public StreamInputPacketReader getPacketReader() { - return packetReader; + return fPacketReader; } @Override public int hashCode() { final int prime = 31; int result = 1; - result = (prime * result) + name; + result = (prime * result) + fId; result = (prime * result) - + ((streamInput == null) ? 0 : streamInput.hashCode()); + + ((fStreamInput == null) ? 0 : fStreamInput.hashCode()); return result; } @@ -436,14 +436,14 @@ public class StreamInputReader { return false; } StreamInputReader other = (StreamInputReader) obj; - if (name != other.name) { + if (fId != other.fId) { return false; } - if (streamInput == null) { - if (other.streamInput != null) { + if (fStreamInput == null) { + if (other.fStreamInput != null) { return false; } - } else if (!streamInput.equals(other.streamInput)) { + } else if (!fStreamInput.equals(other.fStreamInput)) { return false; } return true; @@ -452,6 +452,6 @@ public class StreamInputReader { @Override public String toString() { // this helps debugging - return this.name + ' ' + this.currentEvent.toString(); + return fId + ' ' + fCurrentEvent.toString(); } }