/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** 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, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qobject.h"

#include "qobject_p.h"

#include "qmetaobject_p.h"

#include "qabstracteventdispatcher.h"

#include "qcoreapplication.h"

#include "qcoreapplication_p.h"

#include "qvariant.h"

#include "qmetaobject.h"

#include <qregexp.h>

#include <qthread.h>

#include <private/qthread_p.h>

#include <qdebug.h>

#include <qhash.h>

#include <qpair.h>

#include <qvarlengtharray.h>

#include <qset.h>

#include <qsemaphore.h>

#include <qsharedpointer.h>

#include <private/qorderedmutexlocker_p.h>

#include <private/qmutexpool_p.h>

#include <new>

#include <ctype.h>

#include <limits.h>

QT_BEGIN_NAMESPACE

static int DIRECT_CONNECTION_ONLY = 0;

static int *queuedConnectionTypes(const QList<QByteArray> &typeNames)

{

    int *types = new int [typeNames.count() + 1];

    Q_CHECK_PTR(types);

    for (int i = 0; i < typeNames.count(); ++i) {

        const QByteArray typeName = typeNames.at(i);

        if (typeName.endsWith('*'))

            types[i] = QMetaType::VoidStar;

        else

            types[i] = QMetaType::type(typeName);

        if (!types[i]) {

            qWarning("QObject::connect: Cannot queue arguments of type '%s'\n"

                     "(Make sure '%s' is registered using qRegisterMetaType().)",

                     typeName.constData(), typeName.constData());

            delete [] types;

            return 0;

        }

    }

    types[typeNames.count()] = 0;

    return types;

}

static QBasicAtomicPointer<QMutexPool> signalSlotMutexes = Q_BASIC_ATOMIC_INITIALIZER(0);

static QBasicAtomicInt objectCount = Q_BASIC_ATOMIC_INITIALIZER(0);

/** \internal

 * mutex to be locked when accessing the connectionlists or the senders list

 */

static QMutex *signalSlotLock(const QObject *o)

{

    if (!signalSlotMutexes) {

        QMutexPool *mp = new QMutexPool;

        if (!signalSlotMutexes.testAndSetOrdered(0, mp)) {

            delete mp;

        }

    }

    return signalSlotMutexes->get(o);

}

extern "C" Q_CORE_EXPORT void qt_addObject(QObject *)

{

    objectCount.ref();

}

extern "C" Q_CORE_EXPORT void qt_removeObject(QObject *)

{

    if(!objectCount.deref()) {

        QMutexPool *old = signalSlotMutexes.fetchAndStoreAcquire(0);

        delete old;

    }

}

QObjectData::~QObjectData() {}

QDeclarativeData::~QDeclarativeData() {}

QObjectPrivate::QObjectPrivate(int version)

    : threadData(0), connectionLists(0), senders(0), currentSender(0), currentChildBeingDeleted(0)

{

    if (version != QObjectPrivateVersion)

        qFatal("Cannot mix incompatible Qt libraries");

    // QObjectData initialization

    q_ptr = 0;

    parent = 0;                                 // no parent yet. It is set by setParent()

    isWidget = false;                           // assume not a widget object

    pendTimer = false;                          // no timers yet

    blockSig = false;                           // not blocking signals

    wasDeleted = false;                         // double-delete catcher

    sendChildEvents = true;                     // if we should send ChildInsert and ChildRemove events to parent

    receiveChildEvents = true;

    postedEvents = 0;

    extraData = 0;

    connectedSignals[0] = connectedSignals[1] = 0;

    inEventHandler = false;

    inThreadChangeEvent = false;

    deleteWatch = 0;

    metaObject = 0;

    hasGuards = false;

}

QObjectPrivate::~QObjectPrivate()

{

    delete static_cast<QAbstractDynamicMetaObject*>(metaObject);

    if (deleteWatch)

        *deleteWatch = 1;

#ifndef QT_NO_USERDATA

    if (extraData)

        qDeleteAll(extraData->userData);

    delete extraData;

#endif

}

int *QObjectPrivate::setDeleteWatch(QObjectPrivate *d, int *w) {

    int *old = d->deleteWatch;

    d->deleteWatch = w;

    return old;

}

void QObjectPrivate::resetDeleteWatch(QObjectPrivate *d, int *oldWatch, int deleteWatch) {

    if (!deleteWatch)

        d->deleteWatch = oldWatch;

    if (oldWatch)

        *oldWatch = deleteWatch;

}

#ifdef QT3_SUPPORT

void QObjectPrivate::sendPendingChildInsertedEvents()

{

    Q_Q(QObject);

    for (int i = 0; i < pendingChildInsertedEvents.size(); ++i) {

        QObject *c = pendingChildInsertedEvents.at(i);

        if (!c)

            continue;

        QChildEvent childEvent(QEvent::ChildInserted, c);

        QCoreApplication::sendEvent(q, &childEvent);

    }

    pendingChildInsertedEvents.clear();

}

void QObjectPrivate::removePendingChildInsertedEvents(QObject *child)

{

    if (!child) {

        pendingChildInsertedEvents.clear();

        return;

    }

    // the QObject destructor calls QObject::removeChild, which calls

    // QCoreApplication::sendEvent() directly.  this can happen while the event

    // loop is in the middle of posting events, and when we get here, we may

    // not have any more posted events for this object.

    // if this is a child remove event and the child insert hasn't

    // been dispatched yet, kill that insert

    for (int i = 0; i < pendingChildInsertedEvents.size(); ++i) {

        QObject *&c = pendingChildInsertedEvents[i];

        if (c == child)

            c = 0;

    }

}

#endif

/*!\internal

  For a given metaobject, compute the signal offset, and the method offset (including signals)

*/

static void computeOffsets(const QMetaObject *metaobject, int *signalOffset, int *methodOffset)

{

    *signalOffset = *methodOffset = 0;

    const QMetaObject *m = metaobject->d.superdata;

    while (m) {

        const QMetaObjectPrivate *d = QMetaObjectPrivate::get(m);

        *methodOffset += d->methodCount;

        *signalOffset += (d->revision >= 4) ? d->signalCount : d->methodCount;

        /*Before Qt 4.6 (revision 4), the signalCount information was not generated by moc.

           so for compatibility we consider all the method as slot for old moc output*/

        m = m->d.superdata;

    }

}

/*

    This vector contains the all connections from an object.

    Each object may have one vector containing the lists of

    connections for a given signal. The index in the vector correspond

    to the signal index. The signal index is the one returned by

    QObjectPrivate::signalIndex (not QMetaObject::indexOfSignal).

    Negative index means connections to all signals.

    This vector is protected by the object mutex (signalSlotMutexes())

    Each Connection is also part of a 'senders' linked list. The mutex

    of the receiver must be locked when touching the pointers of this

    linked list.

*/

class QObjectConnectionListVector : public QVector<QObjectPrivate::ConnectionList>

{

public:

    bool orphaned; //the QObject owner of this vector has been destroyed while the vector was inUse

    bool dirty; //some Connection have been disconnected (their receiver is 0) but not removed from the list yet

    int inUse; //number of functions that are currently accessing this object or its connections

    QObjectPrivate::ConnectionList allsignals;

    QObjectConnectionListVector()

        : QVector<QObjectPrivate::ConnectionList>(), orphaned(false), dirty(false), inUse(0)

    { }

    const QObjectPrivate::ConnectionList &at(int at) const

    {

        if (at < 0)

            return allsignals;

        return QVector<QObjectPrivate::ConnectionList>::at(at);

    }

    QObjectPrivate::ConnectionList &operator[](int at)

    {

        if (at < 0)

            return allsignals;

        return QVector<QObjectPrivate::ConnectionList>::operator[](at);

    }

};

// Used by QAccessibleWidget

bool QObjectPrivate::isSender(const QObject *receiver, const char *signal) const

{

    Q_Q(const QObject);

    int signal_index = signalIndex(signal);

    if (signal_index < 0)

        return false;

    QMutexLocker locker(signalSlotLock(q));

    if (connectionLists) {

        if (signal_index < connectionLists->count()) {

            const QObjectPrivate::Connection *c =

                connectionLists->at(signal_index).first;

            while (c) {

                if (c->receiver == receiver)

                    return true;

                c = c->nextConnectionList;

            }

        }

    }

    return false;

}

// Used by QAccessibleWidget

QObjectList QObjectPrivate::receiverList(const char *signal) const

{

    Q_Q(const QObject);

    QObjectList returnValue;

    int signal_index = signalIndex(signal);

    if (signal_index < 0)

        return returnValue;

    QMutexLocker locker(signalSlotLock(q));

    if (connectionLists) {

        if (signal_index < connectionLists->count()) {

            const QObjectPrivate::Connection *c = connectionLists->at(signal_index).first;

            while (c) {

                if (c->receiver)

                    returnValue << c->receiver;

                c = c->nextConnectionList;

            }

        }

    }

    return returnValue;

}

// Used by QAccessibleWidget

QObjectList QObjectPrivate::senderList() const

{

    QObjectList returnValue;

    QMutexLocker locker(signalSlotLock(q_func()));

    for (Connection *c = senders; c; c = c->next)

        returnValue << c->sender;

    return returnValue;

}

void QObjectPrivate::addConnection(int signal, Connection *c)

{

    if (!connectionLists)

        connectionLists = new QObjectConnectionListVector();

    if (signal >= connectionLists->count())

        connectionLists->resize(signal + 1);

    ConnectionList &connectionList = (*connectionLists)[signal];

    if (connectionList.last) {

        connectionList.last->nextConnectionList = c;

    } else {

        connectionList.first = c;

    }

    connectionList.last = c;

    cleanConnectionLists();

}

void QObjectPrivate::cleanConnectionLists()

{

    if (connectionLists->dirty && !connectionLists->inUse) {

        // remove broken connections

        for (int signal = -1; signal < connectionLists->count(); ++signal) {

            QObjectPrivate::ConnectionList &connectionList =

                (*connectionLists)[signal];

            // Set to the last entry in the connection list that was *not*

            // deleted.  This is needed to update the list's last pointer

            // at the end of the cleanup.

            QObjectPrivate::Connection *last = 0;

            QObjectPrivate::Connection **prev = &connectionList.first;

            QObjectPrivate::Connection *c = *prev;

            while (c) {

                if (c->receiver) {

                    last = c;

                    prev = &c->nextConnectionList;

                    c = *prev;

                } else {

                    QObjectPrivate::Connection *next = c->nextConnectionList;

                    *prev = next;

                    delete c;

                    c = next;

                }

            }

            // Correct the connection list's last pointer.

            // As conectionList.last could equal last, this could be a noop

            connectionList.last = last;

        }

        connectionLists->dirty = false;

    }

}

QObjectPrivate::Sender *QObjectPrivate::setCurrentSender(QObject *receiver,

                                                         Sender *sender)

{

    Sender *previousSender = receiver->d_func()->currentSender;

    receiver->d_func()->currentSender = sender;

    return previousSender;

}

void QObjectPrivate::resetCurrentSender(QObject *receiver,

                                        Sender *currentSender,

                                        Sender *previousSender)

{

    // ref is set to zero when this object is deleted during the metacall

    if (currentSender->ref == 1)

        receiver->d_func()->currentSender = previousSender;

    // if we've recursed, we need to tell the caller about the objects deletion

    if (previousSender)

        previousSender->ref = currentSender->ref;

}

typedef QMultiHash<QObject *, QObject **> GuardHash;

Q_GLOBAL_STATIC(GuardHash, guardHash)

Q_GLOBAL_STATIC(QMutex, guardHashLock)

/*!\internal

 */

void QMetaObject::addGuard(QObject **ptr)

{

    if (!*ptr)

        return;

    GuardHash *hash = guardHash();

    if (!hash) {

        *ptr = 0;

        return;

    }

    QMutexLocker locker(guardHashLock());

    QObjectPrivate::get(*ptr)->hasGuards = true;

    hash->insert(*ptr, ptr);

}

/*!\internal

 */

void QMetaObject::removeGuard(QObject **ptr)

{

    if (!*ptr)

        return;

    GuardHash *hash = guardHash();

    /* check that the hash is empty - otherwise we might detach

       the shared_null hash, which will alloc, which is not nice */

    if (!hash || hash->isEmpty())

        return;

    QMutexLocker locker(guardHashLock());

    GuardHash::iterator it = hash->find(*ptr);

    const GuardHash::iterator end = hash->end();

    bool more = false; //if the QObject has more pointer attached to it.

    for (; it.key() == *ptr && it != end; ++it) {

        if (it.value() == ptr) {

            it = hash->erase(it);

            if (!more) more = (it != end && it.key() == *ptr);

            break;

        }

        more = true;

    }

    if (!more)

        QObjectPrivate::get(*ptr)->hasGuards = false;

}

/*!\internal

 */

void QMetaObject::changeGuard(QObject **ptr, QObject *o)

{

    GuardHash *hash = guardHash();

    if (!hash) {

        *ptr = 0;

        return;

    }

    QMutexLocker locker(guardHashLock());

    if (o) {

        hash->insert(o, ptr);

        QObjectPrivate::get(o)->hasGuards = true;

    }

    if (*ptr) {

        bool more = false; //if the QObject has more pointer attached to it.

        GuardHash::iterator it = hash->find(*ptr);

        const GuardHash::iterator end = hash->end();

        for (; it.key() == *ptr && it != end; ++it) {

            if (it.value() == ptr) {

                it = hash->erase(it);

                if (!more) more = (it != end && it.key() == *ptr);

                break;

            }

            more = true;

        }

        if (!more)

            QObjectPrivate::get(*ptr)->hasGuards = false;

    }

    *ptr = o;

}

/*! \internal

 */

void QObjectPrivate::clearGuards(QObject *object)

{

    QObjectPrivate *priv = QObjectPrivate::get(object);

    QGuard<QObject> *guard = priv->extraData ? priv->extraData->objectGuards : 0;

    while (guard) {

        QGuard<QObject> *g = guard;

        guard = guard->next;

        g->o = 0;

        g->prev = 0;

        g->next = 0;

        g->objectDestroyed(object);

    }

    if (!priv->hasGuards)

        return;

    GuardHash *hash = 0;

    QMutex *mutex = 0;

    QT_TRY {

        hash = guardHash();

        mutex = guardHashLock();

    } QT_CATCH(const std::bad_alloc &) {

        // do nothing in case of OOM - code below is safe

    }

    /* check that the hash is empty - otherwise we might detach

       the shared_null hash, which will alloc, which is not nice */

    if (hash && !hash->isEmpty()) {

        QMutexLocker locker(mutex);

        GuardHash::iterator it = hash->find(object);

        const GuardHash::iterator end = hash->end();

        while (it.key() == object && it != end) {

            *it.value() = 0;

            it = hash->erase(it);