lttng: Javadoc udpate for the lttng2.kernel.ui package

[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / views / timechart / TimeChartAnalysisEntry.java

/*******************************************************************************\r
 * Copyright (c) 2010 Ericsson\r
 *\r
 * All rights reserved. This program and the accompanying materials are\r
 * made available under the terms of the Eclipse Public License v1.0 which\r
 * accompanies this distribution, and is available at\r
 * http://www.eclipse.org/legal/epl-v10.html\r
 *\r
 * Contributors:\r
 *   Patrick Tasse - Initial API and implementation\r
 *******************************************************************************/\r
\r
package org.eclipse.linuxtools.tmf.ui.views.timechart;\r
\r
import java.util.Iterator;\r
import java.util.NoSuchElementException;\r
import java.util.Vector;\r
\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;\r
\r
/**\r
 * An entry (row) in the time chart analysis view\r
 *\r
 * @version 1.0\r
 * @author Patrick Tasse\r
 */\r
public class TimeChartAnalysisEntry implements ITimeGraphEntry {\r
\r
    private final ITmfTrace<?> fTrace;\r
    private final Vector<TimeChartEvent> fTraceEvents;\r
    private int fPower = 0; // 2^fPower nanoseconds per vector position\r
    private long fReferenceTime = -1; // time corresponding to beginning of index 0\r
    private long fStartTime = -1; // time of first event\r
    private long fStopTime = -1; // time of last event\r
    private long fLastRank = -1; // rank of last processed trace event\r
\r
    TimeChartAnalysisEntry(ITmfTrace<?> trace, int modelSize) {\r
        fTrace = trace;\r
        fTraceEvents = new Vector<TimeChartEvent>(modelSize);\r
    }\r
\r
    @Override\r
    public ITimeGraphEntry[] getChildren() {\r
        return null;\r
    }\r
\r
    @Override\r
    public ITimeGraphEntry getParent() {\r
        return null;\r
    }\r
\r
    @Override\r
    public boolean hasChildren() {\r
        return false;\r
    }\r
\r
    @Override\r
    public String getName() {\r
        return fTrace.getName();\r
    }\r
\r
    @Override\r
    public long getStartTime() {\r
        return fStartTime;\r
    }\r
\r
    @Override\r
    public long getEndTime() {\r
        return fStopTime;\r
    }\r
\r
    @Override\r
    public boolean hasTimeEvents() {\r
        return true;\r
    }\r
\r
    @Override\r
    public Iterator<ITimeEvent> getTimeEventsIterator() {\r
        return new EntryIterator(0, Long.MAX_VALUE, 0);\r
    }\r
\r
    @Override\r
    public Iterator<ITimeEvent> getTimeEventsIterator(long startTime, long stopTime, long maxDuration) {\r
        return new EntryIterator(startTime, stopTime, maxDuration);\r
    }\r
\r
    private class EntryIterator implements Iterator<ITimeEvent> {\r
        private final long fIteratorStartTime;\r
        private final long fIteratorStopTime;\r
        private final long fIteratorMaxDuration;\r
        private long lastTime = -1;\r
        private TimeChartEvent next = null;\r
        private Iterator<ITimeEvent> nestedIterator = null;\r
\r
        public EntryIterator(long startTime, long stopTime, long maxDuration) {\r
            fIteratorStartTime = startTime;\r
            fIteratorStopTime = stopTime;\r
            fIteratorMaxDuration = maxDuration;\r
        }\r
\r
        @Override\r
        public boolean hasNext() {\r
            synchronized (fTraceEvents) {\r
                if (next != null) {\r
                    return true;\r
                }\r
                if (nestedIterator != null) {\r
                    if (nestedIterator.hasNext()) {\r
                        return true;\r
                    } else {\r
                        nestedIterator = null;\r
                    }\r
                }\r
                long time = (lastTime == -1) ? fStartTime : lastTime;\r
                int index = (fReferenceTime == -1) ? 0 : (int) ((time - fReferenceTime) >> fPower);\r
                while (index < fTraceEvents.size()) {\r
                    TimeChartEvent event = fTraceEvents.get(index++);\r
                    if (event != null && (lastTime == -1 || event.getTime() > time)) {\r
                        if (event.getTime() + event.getDuration() >= fIteratorStartTime && event.getTime() <= fIteratorStopTime) {\r
                            if (event.getItemizedEntry() == null || event.getDuration() <= fIteratorMaxDuration) {\r
                                lastTime = event.getTime() + event.getDuration();\r
                                next = event;\r
                                return true;\r
                            } else {\r
                                nestedIterator = event.getItemizedEntry().getTimeEventsIterator(fIteratorStartTime, fIteratorStopTime, fIteratorMaxDuration);\r
                                return nestedIterator.hasNext();\r
                            }\r
                        }\r
                    }\r
                }\r
                return false;\r
            }\r
        }\r
\r
        @Override\r
        public TimeChartEvent next() {\r
            synchronized (fTraceEvents) {\r
                if (nestedIterator != null) {\r
                    TimeChartEvent event = (TimeChartEvent) nestedIterator.next();\r
                    lastTime = event.getTime() + event.getDuration();\r
                    return event;\r
                }\r
                if (hasNext()) {\r
                    TimeChartEvent event = next;\r
                    next = null;\r
                    return event;\r
                }\r
                throw new NoSuchElementException();\r
            }\r
        }\r
\r
        @Override\r
        public void remove() {\r
            throw new UnsupportedOperationException();\r
        }\r
\r
    }\r
\r
    public void addTraceEvent(ITimeEvent timeEvent) {\r
        long time = timeEvent.getTime();\r
        synchronized (fTraceEvents) {\r
            long index = (fReferenceTime == -1) ? 0 : (time - fReferenceTime) >> fPower;\r
            if (index < 0) {\r
                if (fTraceEvents.capacity() - fTraceEvents.size() < -index) {\r
                    int powershift = (-index + fTraceEvents.size() <= 2 * fTraceEvents.capacity()) ? 1 :\r
                        (int) Math.ceil(Math.log((double) (-index + fTraceEvents.size()) / fTraceEvents.capacity()) / Math.log(2));\r
                    merge(powershift);\r
                    index = (int) ((time - fReferenceTime) >> fPower);\r
                }\r
                shift((int) -index);\r
                index = 0;\r
                fTraceEvents.set(0, (TimeChartEvent) timeEvent);\r
            } else if (index < fTraceEvents.capacity()) {\r
                if (index >= fTraceEvents.size()) {\r
                    fTraceEvents.setSize((int) index + 1);\r
                }\r
            } else {\r
                int powershift = (index < 2 * fTraceEvents.capacity()) ? 1 :\r
                    (int) Math.ceil(Math.log((double) (index + 1) / fTraceEvents.capacity()) / Math.log(2));\r
                merge(powershift);\r
                index = (int) ((time - fReferenceTime) >> fPower);\r
                fTraceEvents.setSize((int) index + 1);\r
            }\r
            TimeChartEvent event = (TimeChartEvent) fTraceEvents.get((int) index);\r
            if (event == null) {\r
                fTraceEvents.set((int) index, (TimeChartEvent) timeEvent);\r
            } else {\r
                if (event.getItemizedEntry() == null) {\r
                    event.merge((TimeChartEvent) timeEvent);\r
                } else {\r
                	event.mergeDecorations((TimeChartEvent) timeEvent);\r
                    event.getItemizedEntry().addTraceEvent(timeEvent);\r
                }\r
            }\r
            if (fReferenceTime == -1 || time < fReferenceTime) {\r
                fReferenceTime = (time >> fPower) << fPower;\r
            }\r
            if (fStartTime == -1 || time < fStartTime) {\r
                fStartTime = time;\r
            }\r
            if (fStopTime == -1 || time > fStopTime) {\r
                fStopTime = time;\r
            }\r
        }\r
    }\r
\r
    private void merge(int powershift) {\r
        fPower += powershift;\r
        fReferenceTime = (fReferenceTime >> fPower) << fPower;\r
        int index = 0;\r
        for (int i = 0; i < fTraceEvents.size(); i++) {\r
            TimeChartEvent event = fTraceEvents.get(i);\r
            if (event != null) {\r
                index = (int) ((event.getTime() - fReferenceTime) >> fPower);\r
                TimeChartEvent mergedEvent = (TimeChartEvent) fTraceEvents.get(index);\r
                if (mergedEvent == null) {\r
                    fTraceEvents.set(index, event);\r
                } else {\r
                    mergedEvent.merge(event);\r
                }\r
                if (i != index) {\r
                    fTraceEvents.set(i, null);\r
                }\r
            }\r
        }\r
        fTraceEvents.setSize(index + 1);\r
    }\r
\r
    private void shift(int indexshift) {\r
        int oldSize = fTraceEvents.size();\r
        fTraceEvents.setSize(oldSize + indexshift);\r
        for (int i = oldSize - 1; i >= 0; i--) {\r
            fTraceEvents.set(i + indexshift, fTraceEvents.get(i));\r
        }\r
        for (int i = 0; i < indexshift; i++) {\r
            fTraceEvents.set(i, null);\r
        }\r
    }\r
\r
    public ITmfTrace<?> getTrace() {\r
        return fTrace;\r
    }\r
\r
    public void setLastRank(long rank) {\r
        fLastRank = rank;\r
    }\r
\r
    public long getLastRank() {\r
        return fLastRank;\r
    }\r
}\r