feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Move SignalType into processinterface.h

Browse Source 
Rename it into ProcessSignalType. It's going to be
used in new interface.

Change-Id: Ifbab8bbb601f14ecbf65d940e524c558d5f1d7a1
Reviewed-by: hjk <hjk@qt.io>
This commit is contained in:
Jarek Kobus
2022-06-08 08:49:27 +02:00
parent cf47ad361d
commit 224f580924
2 changed files with 33 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/libs/utils/processinterface.h
View File

@@ -79,6 +79,12 @@ enum class ControlSignal {
KickOff KickOff
}; };
enum class ProcessSignalType {
Started,
ReadyRead,
Done
};
class QTCREATOR_UTILS_EXPORT ProcessInterface : public QObject class QTCREATOR_UTILS_EXPORT ProcessInterface : public QObject
{ {
Q_OBJECT Q_OBJECT

58
src/libs/utils/qtcprocess.cpp
View File

@@ -485,28 +485,22 @@ static ProcessImpl defaultProcessImpl()
return ProcessImpl::ProcessLauncher; return ProcessImpl::ProcessLauncher;
} }
enum class SignalType {
Started,
ReadyRead,
Done
};
class ProcessInterfaceSignal class ProcessInterfaceSignal
{ {
public: public:
SignalType signalType() const { return m_signalType; } ProcessSignalType signalType() const { return m_signalType; }
virtual ~ProcessInterfaceSignal() = default; virtual ~ProcessInterfaceSignal() = default;
protected: protected:
ProcessInterfaceSignal(SignalType signalType) : m_signalType(signalType) {} ProcessInterfaceSignal(ProcessSignalType signalType) : m_signalType(signalType) {}
private: private:
const SignalType m_signalType; const ProcessSignalType m_signalType;
}; };
class StartedSignal : public ProcessInterfaceSignal class StartedSignal : public ProcessInterfaceSignal
{ {
public: public:
StartedSignal(qint64 processId, qint64 applicationMainThreadId) StartedSignal(qint64 processId, qint64 applicationMainThreadId)
: ProcessInterfaceSignal(SignalType::Started) : ProcessInterfaceSignal(ProcessSignalType::Started)
, m_processId(processId) , m_processId(processId)
, m_applicationMainThreadId(applicationMainThreadId) {} , m_applicationMainThreadId(applicationMainThreadId) {}
qint64 processId() const { return m_processId; } qint64 processId() const { return m_processId; }
@@ -520,7 +514,7 @@ class ReadyReadSignal : public ProcessInterfaceSignal
{ {
public: public:
ReadyReadSignal(const QByteArray &stdOut, const QByteArray &stdErr) ReadyReadSignal(const QByteArray &stdOut, const QByteArray &stdErr)
: ProcessInterfaceSignal(SignalType::ReadyRead) : ProcessInterfaceSignal(ProcessSignalType::ReadyRead)
, m_stdOut(stdOut) , m_stdOut(stdOut)
, m_stdErr(stdErr) {} , m_stdErr(stdErr) {}
QByteArray stdOut() const { return m_stdOut; } QByteArray stdOut() const { return m_stdOut; }
@@ -534,7 +528,7 @@ class DoneSignal : public ProcessInterfaceSignal
{ {
public: public:
DoneSignal(const ProcessResultData &resultData) DoneSignal(const ProcessResultData &resultData)
: ProcessInterfaceSignal(SignalType::Done) : ProcessInterfaceSignal(ProcessSignalType::Done)
, m_resultData(resultData) {} , m_resultData(resultData) {}
ProcessResultData resultData() const { return m_resultData; } ProcessResultData resultData() const { return m_resultData; }
private: private:
@@ -547,7 +541,7 @@ public:
ProcessInterfaceHandler(QtcProcessPrivate *caller, ProcessInterface *process); ProcessInterfaceHandler(QtcProcessPrivate *caller, ProcessInterface *process);
// Called from caller's thread exclusively. // Called from caller's thread exclusively.
bool waitForSignal(int msecs, SignalType newSignal); bool waitForSignal(int msecs, ProcessSignalType newSignal);
void moveToCallerThread(); void moveToCallerThread();
void startKillTimer(int killTimeout); void startKillTimer(int killTimeout);
@@ -651,16 +645,16 @@ public:
// === ProcessInterfaceHandler related === // === ProcessInterfaceHandler related ===
// Called from caller's thread exclusively // Called from caller's thread exclusively
bool waitForSignal(int msecs, SignalType newSignal); bool waitForSignal(int msecs, ProcessSignalType newSignal);
void flush() { flushSignals(takeAllSignals()); } void flush() { flushSignals(takeAllSignals()); }
bool flushFor(SignalType signalType) { bool flushFor(ProcessSignalType signalType) {
return flushSignals(takeSignalsFor(signalType), &signalType); return flushSignals(takeSignalsFor(signalType), &signalType);
} }
QList<ProcessInterfaceSignal *> takeAllSignals(); QList<ProcessInterfaceSignal *> takeAllSignals();
QList<ProcessInterfaceSignal *> takeSignalsFor(SignalType signalType); QList<ProcessInterfaceSignal *> takeSignalsFor(ProcessSignalType signalType);
bool flushSignals(const QList<ProcessInterfaceSignal *> &signalList, bool flushSignals(const QList<ProcessInterfaceSignal *> &signalList,
SignalType *signalType = nullptr); ProcessSignalType *signalType = nullptr);
bool shouldFlush() const { QMutexLocker locker(&m_mutex); return !m_signals.isEmpty(); } bool shouldFlush() const { QMutexLocker locker(&m_mutex); return !m_signals.isEmpty(); }
Qt::ConnectionType connectionType() const; Qt::ConnectionType connectionType() const;
@@ -709,7 +703,7 @@ ProcessInterfaceHandler::ProcessInterfaceHandler(QtcProcessPrivate *caller,
} }
// Called from caller's thread exclusively. // Called from caller's thread exclusively.
bool ProcessInterfaceHandler::waitForSignal(int msecs, SignalType newSignal) bool ProcessInterfaceHandler::waitForSignal(int msecs, ProcessSignalType newSignal)
{ {
QDeadlineTimer deadline(msecs); QDeadlineTimer deadline(msecs);
while (true) { while (true) {
@@ -784,7 +778,7 @@ void ProcessInterfaceHandler::appendSignal(ProcessInterfaceSignal *newSignal)
} }
// Called from caller's thread exclusively // Called from caller's thread exclusively
bool QtcProcessPrivate::waitForSignal(int msecs, SignalType newSignal) bool QtcProcessPrivate::waitForSignal(int msecs, ProcessSignalType newSignal)
{ {
m_processHandler->setParent(nullptr); m_processHandler->setParent(nullptr);
@@ -811,14 +805,14 @@ QList<ProcessInterfaceSignal *> QtcProcessPrivate::takeAllSignals()
} }
// Called from caller's thread exclusively // Called from caller's thread exclusively
QList<ProcessInterfaceSignal *> QtcProcessPrivate::takeSignalsFor(SignalType signalType) QList<ProcessInterfaceSignal *> QtcProcessPrivate::takeSignalsFor(ProcessSignalType signalType)
{ {
// If we are flushing for ReadyRead or Done - flush all. // If we are flushing for ReadyRead or Done - flush all.
if (signalType != SignalType::Started) if (signalType != ProcessSignalType::Started)
return takeAllSignals(); return takeAllSignals();
QMutexLocker locker(&m_mutex); QMutexLocker locker(&m_mutex);
const QList<SignalType> storedSignals = transform(qAsConst(m_signals), const QList<ProcessSignalType> storedSignals = transform(qAsConst(m_signals),
[](const ProcessInterfaceSignal *aSignal) { [](const ProcessInterfaceSignal *aSignal) {
return aSignal->signalType(); return aSignal->signalType();
}); });
@@ -826,8 +820,10 @@ QList<ProcessInterfaceSignal *> QtcProcessPrivate::takeSignalsFor(SignalType sig
// If we are flushing for Started: // If we are flushing for Started:
// - if Started was buffered - flush Started only (even when Done was buffered) // - if Started was buffered - flush Started only (even when Done was buffered)
// - otherwise if Done signal was buffered - flush all. // - otherwise if Done signal was buffered - flush all.
if (!storedSignals.contains(SignalType::Started) && storedSignals.contains(SignalType::Done)) if (!storedSignals.contains(ProcessSignalType::Started)
&& storedSignals.contains(ProcessSignalType::Done)) {
return std::exchange(m_signals, {}); // avoid takeAllSignals() because of mutex locked return std::exchange(m_signals, {}); // avoid takeAllSignals() because of mutex locked
}
QList<ProcessInterfaceSignal *> oldSignals; QList<ProcessInterfaceSignal *> oldSignals;
const auto matchingIndex = storedSignals.lastIndexOf(signalType); const auto matchingIndex = storedSignals.lastIndexOf(signalType);
@@ -840,21 +836,21 @@ QList<ProcessInterfaceSignal *> QtcProcessPrivate::takeSignalsFor(SignalType sig
// Called from caller's thread exclusively // Called from caller's thread exclusively
bool QtcProcessPrivate::flushSignals(const QList<ProcessInterfaceSignal *> &signalList, bool QtcProcessPrivate::flushSignals(const QList<ProcessInterfaceSignal *> &signalList,
SignalType *signalType) ProcessSignalType *signalType)
{ {
bool signalMatched = false; bool signalMatched = false;
for (const ProcessInterfaceSignal *storedSignal : qAsConst(signalList)) { for (const ProcessInterfaceSignal *storedSignal : qAsConst(signalList)) {
const SignalType storedSignalType = storedSignal->signalType(); const ProcessSignalType storedSignalType = storedSignal->signalType();
if (signalType && storedSignalType == *signalType) if (signalType && storedSignalType == *signalType)
signalMatched = true; signalMatched = true;
switch (storedSignalType) { switch (storedSignalType) {
case SignalType::Started: case ProcessSignalType::Started:
handleStartedSignal(static_cast<const StartedSignal *>(storedSignal)); handleStartedSignal(static_cast<const StartedSignal *>(storedSignal));
break; break;
case SignalType::ReadyRead: case ProcessSignalType::ReadyRead:
handleReadyReadSignal(static_cast<const ReadyReadSignal *>(storedSignal)); handleReadyReadSignal(static_cast<const ReadyReadSignal *>(storedSignal));
break; break;
case SignalType::Done: case ProcessSignalType::Done:
if (signalType) if (signalType)
signalMatched = true; signalMatched = true;
handleDoneSignal(static_cast<const DoneSignal *>(storedSignal)); handleDoneSignal(static_cast<const DoneSignal *>(storedSignal));
@@ -1452,7 +1448,7 @@ bool QtcProcess::waitForStarted(int msecs)
if (d->m_state == QProcess::NotRunning) if (d->m_state == QProcess::NotRunning)
return false; return false;
return s_waitForStarted.measureAndRun(&QtcProcessPrivate::waitForSignal, d, msecs, return s_waitForStarted.measureAndRun(&QtcProcessPrivate::waitForSignal, d, msecs,
SignalType::Started); ProcessSignalType::Started);
} }
bool QtcProcess::waitForReadyRead(int msecs) bool QtcProcess::waitForReadyRead(int msecs)
@@ -1460,7 +1456,7 @@ bool QtcProcess::waitForReadyRead(int msecs)
QTC_ASSERT(d->m_process, return false); QTC_ASSERT(d->m_process, return false);
if (d->m_state == QProcess::NotRunning) if (d->m_state == QProcess::NotRunning)
return false; return false;
return d->waitForSignal(msecs, SignalType::ReadyRead); return d->waitForSignal(msecs, ProcessSignalType::ReadyRead);
} }
bool QtcProcess::waitForFinished(int msecs) bool QtcProcess::waitForFinished(int msecs)
@@ -1468,7 +1464,7 @@ bool QtcProcess::waitForFinished(int msecs)
QTC_ASSERT(d->m_process, return false); QTC_ASSERT(d->m_process, return false);
if (d->m_state == QProcess::NotRunning) if (d->m_state == QProcess::NotRunning)
return false; return false;
return d->waitForSignal(msecs, SignalType::Done); return d->waitForSignal(msecs, ProcessSignalType::Done);
} }
QByteArray QtcProcess::readAllStandardOutput() QByteArray QtcProcess::readAllStandardOutput()