1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
/****************************************************************************
**
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the Qt Build Suite.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#include "jobs.h"
#include "internaljobs.h"
#include "project.h"
#include <language/scriptengine.h>
namespace qbs {
using namespace Internal;
/*!
* \class AbstractJob
* \brief The \c AbstractJob class represents an operation relating to a \c Project.
* Concrete child classes of \c AbstractJob are created by factory functions in the \c Project
* class. The respective objects represent an operation that is started automatically
* and is considered "running" until the \c finished() signal has been emitted. Afterwards,
* callers can find out whether the operation was successful by calling \c hasError(). While
* the operation is going on, progress information is being provided via \c taskStarted() and
* \c taskProgress.
* Note that though a job is being started automatically by its factory function, you are guaranteed
* to recevieve all signals it emits if you connect to it right after getting the object from the
* creating function.
* \sa Project
*/
/*!
* \enum AbstractJob::State
* This enum type specifies which states a job can be in.
* \value StateRunning The respective operation is ongoing.
* \value StateCanceling The job has been requested to cancel via \c AbstractJob::cancel(),
* but the \c AbstractJob::finished() signal has not been emitted yet.
* \value StateFinished The operation has finished and the \c AbstractJob::finished() signal
* has been emitted.
*/
/*!
* \fn AbstractJob::State AbstractJob::state() const
* \brief Returns the current state of the operation.
*/
/*!
* \fn bool AbstractJob::hasError() const
* \brief Returns true if the operation has finished with an error, otherwise returns false.
* This function should not be called before the \c finished() signal has been emitted.
*/
/*!
* \fn void AbstractJob::taskStarted(const QString &description, int maximumProgressValue, qbs::AbstractJob *job)
* \brief Indicates that a new task has been started.
* The \a description parameter is a string intended for presentation to a user.
* The \a maximumProgressValue parameter indicates the maximum value to which subsequent values of
* \c taskProgress() will go.
* This signal is typically emitted exactly once for a job that finishes successfully. However,
* operations might emit it several times if they are made up of subtasks whose overall effort
* cannot be determined in advance.
* \sa AbstractJob::taskProgress()
*/
/*!
* \fn void taskProgress(int newProgressValue, qbs::AbstractJob *job)
* \brief Indicates progress in executing the operation.
* The \a newProgressValue parameter represents the current progress. It is always greater than
* zero, strictly increasing and goes up to the \c maximumProgressValue argument of the last
* call to \c taskStarted().
* \sa AbstractJob::taskStarted()
*/
/*!
* \fn void finished(bool success, qbs::AbstractJob *job)
* \brief Indicates that the operation has finished.
* Check the \a success parameter to find out whether everything went fine or an error occurred.
*/
AbstractJob::AbstractJob(InternalJob *internalJob, QObject *parent)
: QObject(parent), m_internalJob(internalJob)
{
m_internalJob->setParent(this);
connect(m_internalJob, SIGNAL(newTaskStarted(QString,int,Internal::InternalJob*)),
SLOT(handleTaskStarted(QString,int)));
connect(m_internalJob, SIGNAL(taskProgress(int,Internal::InternalJob*)),
SLOT(handleTaskProgress(int)));
connect(m_internalJob, SIGNAL(finished(Internal::InternalJob *)), SLOT(handleFinished()));
m_state = StateRunning;
}
/*!
* \brief Destroys the object, canceling the operation if necessary.
*/
AbstractJob::~AbstractJob()
{
m_internalJob->disconnect(this);
cancel();
}
/*!
* \brief Returns the error which caused this operation to fail, if it did fail.
*/
Error AbstractJob::error() const
{
return internalJob()->error();
}
/*!
* \brief Cancels this job.
* Note that the job might not finish immediately. If you need to make sure it has actually
* finished, wait for the \c finished() signal.
* \sa AbstractJob::finished(AbstractJob *);
*/
void AbstractJob::cancel()
{
if (m_state != StateRunning)
return;
m_state = StateCanceling;
internalJob()->cancel();
}
void AbstractJob::handleTaskStarted(const QString &description, int maximumProgressValue)
{
emit taskStarted(description, maximumProgressValue, this);
}
void AbstractJob::handleTaskProgress(int newProgressValue)
{
emit taskProgress(newProgressValue, this);
}
void AbstractJob::handleFinished()
{
Q_ASSERT(m_state != StateFinished);
m_state = StateFinished;
emit finished(!hasError(), this);
}
/*!
* \class SetupProjectJob
* \brief The \c SetupProjectJob class represents an operation that reads a qbs project file and
* creates a \c Project object from it.
* Note that this job can emit the \c taskStarted() signal more than once.
* \sa AbstractJob::taskStarted()
*/
SetupProjectJob::SetupProjectJob(QObject *parent) : AbstractJob(new InternalSetupProjectJob, parent)
{
}
/*!
* \brief Returns the project resulting from this operation.
* Note that the result is undefined if the job did not finish successfully.
* \sa AbstractJob::hasError()
*/
Project SetupProjectJob::project() const
{
const InternalSetupProjectJob * const job
= qobject_cast<InternalSetupProjectJob *>(internalJob());
return job->buildProject();
}
void SetupProjectJob::resolve(const QString &projectFilePath, const QString &buildRoot,
const QVariantMap &buildConfig)
{
InternalSetupProjectJob * const job = qobject_cast<InternalSetupProjectJob *>(internalJob());
job->resolve(projectFilePath, buildRoot, buildConfig);
}
/*!
* \class BuildJob
* \brief The \c BuildJob class represents a build operation.
*/
BuildJob::BuildJob(QObject *parent) : AbstractJob(new InternalBuildJob, parent)
{
}
void BuildJob::build(const QList<BuildProduct::Ptr> &products, const BuildOptions &options)
{
qobject_cast<InternalBuildJob *>(internalJob())->build(products, options);
}
/*!
* \class CleanJob
* \brief The \c CleanJob class represents an operation removing build artifacts.
*/
CleanJob::CleanJob(QObject *parent) : AbstractJob(new InternalCleanJob, parent)
{
}
void CleanJob::clean(const QList<BuildProduct::Ptr> &products,
const BuildOptions &options, bool cleanAll)
{
qobject_cast<InternalCleanJob *>(internalJob())->clean(products, options, cleanAll);
}
} // namespace qbs
|
