QQmlAbstractProfilerAdapter Class | QtQml 5.3

- Qt 5.3
- Qt QML
- C++ Classes
- QQmlAbstractProfilerAdapter
- Qt 5.3.2 Reference Documentation

# QQmlAbstractProfilerAdapter Class

Header: | `#include <QQmlAbstractProfilerAdapter>`
qmake: | `QT += qml`

- List of all members, including inherited members

## Public Functions

| QQmlAbstractProfilerAdapter(QQmlProfilerService * service)
virtual | ~QQmlAbstractProfilerAdapter()
bool | isRunning() const
void | reportData()
virtual qint64 | sendMessages(qint64 until, QList<QByteArray> & messages) = 0
void | startProfiling()
void | startWaiting()
void | stopProfiling()
void | stopWaiting()
void | synchronize(const QElapsedTimer & timer)

## Signals

void | dataRequested()
void | profilingDisabled()
void | profilingDisabledWhileWaiting()
void | profilingEnabled()
void | profilingEnabledWhileWaiting()
void | referenceTimeKnown(const QElapsedTimer & timer)

## Detailed Description

Abstract base class for all adapters between profilers and the QQmlProfilerService. Adapters have to retrieve profiler-specific data and convert it to the format sent over the wire. Adapters must live in the QDebugServer thread but the actual profilers can live in different threads. The recommended way to deal with this is passing the profiling data through a signal/slot connection.

## Member Function Documentation

### QQmlAbstractProfilerAdapter::QQmlAbstractProfilerAdapter(QQmlProfilerService * service)

### QQmlAbstractProfilerAdapter::~QQmlAbstractProfilerAdapter()`[virtual]`

### void QQmlAbstractProfilerAdapter::dataRequested()`[signal]`

Signals that data has been requested by the `QQmlProfilerService`. This signal should be connected to a slot in the profiler and the profiler should then transfer its currently available profiling data to the adapter as soon as possible.

### bool QQmlAbstractProfilerAdapter::isRunning() const

Returns if the profiler is currently running. The profiler is considered to be running after `startProfiling()` has been called until `stopProfiling()` is called. That is independent of `waiting`. The profiler may be running and waiting at the same time.

### void QQmlAbstractProfilerAdapter::profilingDisabled()`[signal]`

This signal is emitted if `stopProfiling()` is called while the profiler is not considered to be waiting. The profiler is expected to handle the signal asynchronously.

### void QQmlAbstractProfilerAdapter::profilingDisabledWhileWaiting()`[signal]`

This signal is emitted if `stopProfiling()` is called while the profiler is considered to be waiting. In many cases this signal can be connected with a `Qt::DirectConnection`.

### void QQmlAbstractProfilerAdapter::profilingEnabled()`[signal]`

This signal is emitted if `startProfiling()` is called while the profiler is not considered to be waiting. The profiler is expected to handle the signal asynchronously.

### void QQmlAbstractProfilerAdapter::profilingEnabledWhileWaiting()`[signal]`

This signal is emitted if `startProfiling()` is called while the profiler is considered to be waiting. In many cases this signal can be connected with a `Qt::DirectConnection`. By starting the profiler synchronously when the QML engine starts instead of waiting for the first iteration of the event loop the engine startup can be profiled.

### void QQmlAbstractProfilerAdapter::referenceTimeKnown(const QElapsedTimer & timer)`[signal]`

This signal is used to synchronize the profiler's timer to the QQmlProfilerservice's. The profiler is expected to save timer and use it for timestamps on its data.

### void QQmlAbstractProfilerAdapter::reportData()

Make the profiler report its current data without stopping the collection. The same (and additional) data can later be requested again with `stopProfiling()` or `reportData()`.

### qint64 QQmlAbstractProfilerAdapter::sendMessages(qint64 until, QList<QByteArray> & messages)`[pure virtual]`

Append the messages up to the timestamp until, chronologically sorted, to messages. Keep track of the messages already sent and with each subsequent call to this method start with the first one not yet sent. Messages that have been sent can be deleted. When new data from the profiler arrives the information about the last sent message must be reset. Return the timestamp of the next message after until or `-1` if there is no such message. The profiler service keeps a list of adapters, sorted by time of next message and keeps querying the first one to send messages up to the time of the second one. Like that we get chronologically sorted messages and can occasionally post the messages to exploit parallelism and save memory.

### void QQmlAbstractProfilerAdapter::startProfiling()

Emits either `profilingEnabled()` or `profilingEnabledWhileWaiting()`, depending on `waiting`. If the profiler's thread is waiting for an initial start signal we can emit the signal over a `Qt::DirectConnection` to avoid the delay of the event loop.

### void QQmlAbstractProfilerAdapter::startWaiting()

Consider the profiler to be waiting from now on. While the profiler is waiting it can be directly accessed even if it is in a different thread. This method should only be called if it is actually safe to do so.

### void QQmlAbstractProfilerAdapter::stopProfiling()

Emits either `profilingDisabled()` or `profilingDisabledWhileWaiting()`, depending on `waiting`. If the profiler's thread is waiting for an initial start signal we can emit the signal over a `Qt::DirectConnection` to avoid the delay of the event loop. This should trigger the profiler to report its collected data and subsequently delete it.

### void QQmlAbstractProfilerAdapter::stopWaiting()

Consider the profiler not to be waiting anymore. If it lives in a different threads any requests for it have to be done via a queued connection then.

### void QQmlAbstractProfilerAdapter::synchronize(const QElapsedTimer & timer)

Synchronize the profiler to timer. This emits `referenceTimeKnown()`.