Post.h

/*
 * Copyright 2021-2024 Dmitry Ivanov
 *
 * This file is part of libquentier
 *
 * libquentier is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, version 3 of the License.
 *
 * libquentier is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libquentier. If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <QAbstractEventDispatcher>
#include <QMetaObject>
#include <QObject>
 
#include <QThread>
 
#include <memory>
#include <utility>
 
namespace quentier::threading {
 
template <typename Function>
void postToObject(QObject * object, Function && function)
{
    Q_ASSERT(object);
 
    QMetaObject::invokeMethod(
        object, std::forward<Function>(function), Qt::QueuedConnection);
}
 
template <typename Function>
void postToThread(QThread * pThread, Function && function)
{
    Q_ASSERT(pThread);
    Q_ASSERT(!pThread->isFinished());
 
    QObject * pObject = QAbstractEventDispatcher::instance(pThread);
    if (!pObject) {
        // Thread's event loop has not been started yet. Create a dummy QObject,
        // move it to the target thread, set things up so that it would be
        // destroyed after the job is done and use postToObject.
        auto pDummyObj = std::make_unique<QObject>();
        pDummyObj->moveToThread(pThread);
        postToObject(
            pDummyObj.get(),
            [pObj = pDummyObj.get(),
             function = std::forward<Function>(function)]() mutable {
                pObj->deleteLater();
                function();
            });
        Q_UNUSED(pDummyObj.release()) // NOLINT
        return;
    }
 
    if (pThread == QThread::currentThread()) {
        // Already on the target thread, executing the function right away
        function();
        return;
    }
 
    QMetaObject::invokeMethod(pObject, std::forward<Function>(function));
}
 
} // namespace quentier::threading