qsocketnotifier.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** 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 The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/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 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
 
#define BUILDING_QSOCKETNOTIFIER
#include "qsocketnotifier.h"
#undef BUILDING_QSOCKETNOTIFIER
 
#include "qplatformdefs.h"
 
#include "qabstracteventdispatcher.h"
#include "qcoreapplication.h"
 
#include "qmetatype.h"
 
#include "qobject_p.h"
#include <private/qthread_p.h>
 
#include <QtCore/QLoggingCategory>
 
QT_BEGIN_NAMESPACE
 
Q_DECLARE_LOGGING_CATEGORY(lcSocketNotifierDeprecation)
Q_LOGGING_CATEGORY(lcSocketNotifierDeprecation, "qt.core.socketnotifier_deprecation");
 
QT_IMPL_METATYPE_EXTERN_TAGGED(QSocketNotifier::Type, QSocketNotifier_Type)
QT_IMPL_METATYPE_EXTERN(QSocketDescriptor)
 
class QSocketNotifierPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QSocketNotifier)
public:
    QSocketDescriptor sockfd;
    QSocketNotifier::Type sntype;
    bool snenabled = false;
};
 
QSocketNotifier::QSocketNotifier(Type type, QObject *parent)
    : QObject(*new QSocketNotifierPrivate, parent)
{
    Q_D(QSocketNotifier);
 
    qRegisterMetaType<QSocketDescriptor>();
    qRegisterMetaType<QSocketNotifier::Type>();
 
    d->sntype = type;
}
 
QSocketNotifier::QSocketNotifier(qintptr socket, Type type, QObject *parent)
    : QSocketNotifier(type, parent)
{
    Q_D(QSocketNotifier);
 
    d->sockfd = socket;
    d->snenabled = true;
 
    auto thisThreadData = d->threadData.loadRelaxed();
 
    if (!d->sockfd.isValid())
        qWarning("QSocketNotifier: Invalid socket specified");
    else if (!thisThreadData->hasEventDispatcher())
        qWarning("QSocketNotifier: Can only be used with threads started with QThread");
    else
        thisThreadData->eventDispatcher.loadRelaxed()->registerSocketNotifier(this);
}
 
QSocketNotifier::~QSocketNotifier()
{
    setEnabled(false);
}
 
 
void QSocketNotifier::setSocket(qintptr socket)
{
    Q_D(QSocketNotifier);
 
    setEnabled(false);
    d->sockfd = socket;
}
 
qintptr QSocketNotifier::socket() const
{
    Q_D(const QSocketNotifier);
    return qintptr(d->sockfd);
}
 
QSocketNotifier::Type QSocketNotifier::type() const
{
    Q_D(const QSocketNotifier);
    return d->sntype;
}
 
bool QSocketNotifier::isValid() const
{
    Q_D(const QSocketNotifier);
    return d->sockfd.isValid();
}
 
bool QSocketNotifier::isEnabled() const
{
    Q_D(const QSocketNotifier);
    return d->snenabled;
}
 
void QSocketNotifier::setEnabled(bool enable)
{
    Q_D(QSocketNotifier);
    if (!d->sockfd.isValid())
        return;
    if (d->snenabled == enable)                        // no change
        return;
    d->snenabled = enable;
 
 
    auto thisThreadData = d->threadData.loadRelaxed();
 
    if (!thisThreadData->hasEventDispatcher()) // perhaps application/thread is shutting down
        return;
    if (Q_UNLIKELY(thread() != QThread::currentThread())) {
        qWarning("QSocketNotifier: Socket notifiers cannot be enabled or disabled from another thread");
        return;
    }
    if (d->snenabled)
        thisThreadData->eventDispatcher.loadRelaxed()->registerSocketNotifier(this);
    else
        thisThreadData->eventDispatcher.loadRelaxed()->unregisterSocketNotifier(this);
}
 
 
bool QSocketNotifier::event(QEvent *e)
{
    Q_D(QSocketNotifier);
    // Emits the activated() signal when a QEvent::SockAct or QEvent::SockClose is
    // received.
    switch (e->type()) {
    case QEvent::ThreadChange:
        if (d->snenabled) {
            QMetaObject::invokeMethod(this, "setEnabled", Qt::QueuedConnection,
                                      Q_ARG(bool, d->snenabled));
            setEnabled(false);
        }
        break;
    case QEvent::SockAct:
    case QEvent::SockClose:
        {
            QPointer<QSocketNotifier> alive(this);
            emit activated(d->sockfd, d->sntype, QPrivateSignal());
            // ### Qt7: Remove emission if the activated(int) signal is removed
            if (alive)
                emit activated(int(qintptr(d->sockfd)), QPrivateSignal());
        }
        return true;
    default:
        break;
    }
    return QObject::event(e);
}
 
QT_END_NAMESPACE
 
#include "moc_qsocketnotifier.cpp"