// async if nested cases
void QQmlEnginePrivate::incubate(QQmlIncubator &i, QQmlContextData *forContext)
{
- QQmlIncubatorPrivate *p = i.d;
+ QExplicitlySharedDataPointer<QQmlIncubatorPrivate> p(i.d);
QQmlIncubator::IncubationMode mode = i.incubationMode();
mode = QQmlIncubator::Synchronous;
// Need to find the first constructing context and see if it is asynchronous
- QQmlIncubatorPrivate *parentIncubator = 0;
+ QExplicitlySharedDataPointer<QQmlIncubatorPrivate> parentIncubator;
QQmlContextData *cctxt = forContext;
while (cctxt) {
if (cctxt->activeVMEData) {
if (parentIncubator && parentIncubator->isAsynchronous) {
mode = QQmlIncubator::Asynchronous;
p->waitingOnMe = parentIncubator;
- parentIncubator->waitingFor.insert(p);
+ parentIncubator->waitingFor.insert(p.data());
}
}
inProgressCreations++;
if (mode == QQmlIncubator::Synchronous) {
- typedef QQmlIncubatorPrivate IP;
- QRecursionWatcher<IP, &IP::recursion> watcher(p);
+ QRecursionWatcher<QQmlIncubatorPrivate, &QQmlIncubatorPrivate::recursion> watcher(p.data());
p->changeStatus(QQmlIncubator::Loading);
p->incubate(i);
}
} else {
- incubatorList.insert(p);
+ incubatorList.insert(p.data());
incubatorCount++;
p->vmeGuard.guard(&p->vme);
p->changeStatus(QQmlIncubator::Loading);
if (incubationController)
- incubationController->incubatingObjectCountChanged(incubatorCount);
+ incubationController->incubatingObjectCountChanged(incubatorCount);
}
}
return d->incubationController;
}
-QQmlIncubatorPrivate::QQmlIncubatorPrivate(QQmlIncubator *q,
- QQmlIncubator::IncubationMode m)
-: q(q), status(QQmlIncubator::Null), mode(m), isAsynchronous(false), progress(Execute),
- result(0), compiledData(0), vme(this), waitingOnMe(0)
+QQmlIncubatorPrivate::QQmlIncubatorPrivate(QQmlIncubator *q, QQmlIncubator::IncubationMode m)
+ : q(q), status(QQmlIncubator::Null), mode(m), isAsynchronous(false), progress(Execute),
+ result(0), compiledData(0), vme(this), waitingOnMe(0)
{
}
QQmlIncubatorPrivate::~QQmlIncubatorPrivate()
{
+ clear();
}
void QQmlIncubatorPrivate::clear()
enginePriv->incubatorCount--;
QQmlIncubationController *controller = enginePriv->incubationController;
if (controller)
- controller->incubatingObjectCountChanged(enginePriv->incubatorCount);
+ controller->incubatingObjectCountChanged(enginePriv->incubatorCount);
} else if (compiledData) {
compiledData->release();
compiledData = 0;
*/
int QQmlIncubationController::incubatingObjectCount() const
{
- if (d)
- return d->incubatorCount;
- else
- return 0;
+ return d ? d->incubatorCount : 0;
}
/*!
{
if (!compiledData)
return;
+
QML_MEMORY_SCOPE_URL(compiledData->url);
- typedef QQmlIncubatorPrivate IP;
- QRecursionWatcher<IP, &IP::recursion> watcher(this);
+ QExplicitlySharedDataPointer<QQmlIncubatorPrivate> protectThis(this);
+
+ QRecursionWatcher<QQmlIncubatorPrivate, &QQmlIncubatorPrivate::recursion> watcher(this);
QQmlEngine *engine = compiledData->engine;
QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(engine);
ddata->indestructible = true;
ddata->explicitIndestructibleSet = true;
ddata->rootObjectInCreation = false;
- q->setInitialState(result);
+ if (q)
+ q->setInitialState(result);
}
if (watcher.hasRecursed())
finishIncubate:
if (progress == QQmlIncubatorPrivate::Completed && waitingFor.isEmpty()) {
- typedef QQmlIncubatorPrivate IP;
-
- QQmlIncubatorPrivate *isWaiting = waitingOnMe;
+ QExplicitlySharedDataPointer<QQmlIncubatorPrivate> isWaiting = waitingOnMe;
clear();
if (isWaiting) {
- QRecursionWatcher<IP, &IP::recursion> watcher(isWaiting);
+ QRecursionWatcher<QQmlIncubatorPrivate, &QQmlIncubatorPrivate::recursion> watcher(isWaiting.data());
changeStatus(calculateStatus());
if (!watcher.hasRecursed())
isWaiting->incubate(i);
*/
void QQmlIncubationController::incubateFor(int msecs)
{
- if (!d || d->incubatorCount == 0)
+ if (!d || !d->incubatorCount)
return;
QQmlVME::Interrupt i(msecs * 1000000);
i.reset();
do {
- QQmlIncubatorPrivate *p = (QQmlIncubatorPrivate*)d->incubatorList.first();
- p->incubate(i);
+ static_cast<QQmlIncubatorPrivate*>(d->incubatorList.first())->incubate(i);
} while (d && d->incubatorCount != 0 && !i.shouldInterrupt());
}
*/
void QQmlIncubationController::incubateWhile(volatile bool *flag, int msecs)
{
- if (!d || d->incubatorCount == 0)
+ if (!d || !d->incubatorCount)
return;
QQmlVME::Interrupt i(flag, msecs * 1000000);
i.reset();
do {
- QQmlIncubatorPrivate *p = (QQmlIncubatorPrivate*)d->incubatorList.first();
- p->incubate(i);
+ static_cast<QQmlIncubatorPrivate*>(d->incubatorList.first())->incubate(i);
} while (d && d->incubatorCount != 0 && !i.shouldInterrupt());
}
Create a new incubator with the specified \a mode
*/
QQmlIncubator::QQmlIncubator(IncubationMode mode)
-: d(new QQmlIncubatorPrivate(this, mode))
+ : d(new QQmlIncubatorPrivate(this, mode))
{
+ d->ref.ref();
}
/*! \internal */
QQmlIncubator::~QQmlIncubator()
{
- clear();
+ d->q = 0;
- delete d; d = 0;
+ if (!d->ref.deref()) {
+ delete d;
+ }
+ d = 0;
}
/*!
*/
void QQmlIncubator::clear()
{
- typedef QQmlIncubatorPrivate IP;
- QRecursionWatcher<IP, &IP::recursion> watcher(d);
+ QRecursionWatcher<QQmlIncubatorPrivate, &QQmlIncubatorPrivate::recursion> watcher(d);
Status s = status();
d->clear();
// if we're waiting on any incubators then they should be cleared too.
- while (d->waitingFor.first())
- static_cast<QQmlIncubatorPrivate*>(d->waitingFor.first())->q->clear();
+ while (d->waitingFor.first()) {
+ QQmlIncubator * i = static_cast<QQmlIncubatorPrivate*>(d->waitingFor.first())->q;
+ if (i)
+ i->clear();
+ }
d->vme.reset();
d->vmeGuard.clear();
Q_ASSERT(d->compiledData == 0);
- Q_ASSERT(d->waitingOnMe == 0);
+ Q_ASSERT(d->waitingOnMe.data() == 0);
Q_ASSERT(d->waitingFor.isEmpty());
- Q_ASSERT(!d->nextWaitingFor.isInList());
d->errors.clear();
d->progress = QQmlIncubatorPrivate::Execute;
*/
QObject *QQmlIncubator::object() const
{
- if (status() != Ready) return 0;
- else return d->result;
+ if (status() != Ready)
+ return 0;
+ else
+ return d->result;
}
/*!
return;
status = s;
- q->statusChanged(status);
+ if (q)
+ q->statusChanged(status);
}
QQmlIncubator::Status QQmlIncubatorPrivate::calculateStatus() const
{
if (!errors.isEmpty())
return QQmlIncubator::Error;
- else if (result && progress == QQmlIncubatorPrivate::Completed &&
- waitingFor.isEmpty())
+ else if (result && progress == QQmlIncubatorPrivate::Completed && waitingFor.isEmpty())
return QQmlIncubator::Ready;
else if (compiledData)
return QQmlIncubator::Loading;