154 lines
3.8 KiB
C++
Executable File
154 lines
3.8 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* General Qt-connection
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Christian Fröbel, SLSE, 2017-07-24
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <QObject>
|
|
#include <QMetaObject>
|
|
#include <QPointer>
|
|
#include <QtGlobal>
|
|
#include <type_traits>
|
|
|
|
|
|
namespace LtsUtils
|
|
{
|
|
|
|
/**
|
|
* IConnection represents a general Qt-connection.
|
|
* It is useful in cases where you need to store different Qt-connections
|
|
* for later use.
|
|
* @author Christian Fröbel
|
|
*/
|
|
class IConnection
|
|
{
|
|
public:
|
|
virtual ~IConnection() = default;
|
|
virtual void connect(Qt::ConnectionType = Qt::AutoConnection) = 0;
|
|
virtual void disconnect() = 0;
|
|
};
|
|
|
|
|
|
/**
|
|
* A DummyConnection can be used when there is no connection.
|
|
* connect() and disconnect() are no-ops.
|
|
*/
|
|
class DummyConnection : public IConnection
|
|
{
|
|
public:
|
|
void connect(Qt::ConnectionType = Qt::AutoConnection) override {}
|
|
void disconnect() override {}
|
|
};
|
|
|
|
|
|
namespace detail
|
|
{
|
|
|
|
/**
|
|
* Helper class to extract the class type from a given pointer to member,
|
|
* where member can be an object or a function (aka method).
|
|
* We need it only for methods though.
|
|
* This is just the main template declaration without implementation.
|
|
*/
|
|
template<class T>
|
|
struct ExtractClass;
|
|
|
|
/**
|
|
* Specialization vor pointer to member.
|
|
*/
|
|
template<class T, class Member>
|
|
struct ExtractClass<Member T::*>
|
|
{
|
|
using type = T;
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
|
|
/**
|
|
* Implements a Qt-connection based on the pointer to the methods being connected.
|
|
* The connection can be signal to signal or signal to slot.
|
|
*
|
|
* Connection is guarded against the case where either the signal-emitter
|
|
* or -target is deleted before conntect() is actually called.
|
|
*
|
|
* @param Signal Pointer to method of the Emitter
|
|
* @param Slot Pointer to method of the Target; might also be a signal.
|
|
* @author Christian Fröbel
|
|
*/
|
|
template<class Signal, class Slot>
|
|
class Connection : public IConnection
|
|
{
|
|
static_assert(std::is_member_function_pointer<Signal>::value, "Must be a pointer to method");
|
|
static_assert(std::is_member_function_pointer<Slot>::value, "Must be a pointer to method");
|
|
|
|
using Emitter = typename detail::ExtractClass<Signal>::type;
|
|
using Target = typename detail::ExtractClass<Slot>::type;
|
|
|
|
static_assert(std::is_base_of<QObject, Emitter>::value, "Must be derived from QObject");
|
|
static_assert(std::is_base_of<QObject, Target>::value, "Must be derived from QObject");
|
|
|
|
public:
|
|
Connection(Emitter *emitter, Signal signal, Target *target, Slot slot):
|
|
m_emitter(emitter),
|
|
m_signal(signal),
|
|
m_target(target),
|
|
m_slot(slot)
|
|
{
|
|
Q_ASSERT(emitter);
|
|
Q_ASSERT(signal);
|
|
Q_ASSERT(target);
|
|
Q_ASSERT(slot);
|
|
}
|
|
|
|
void connect(Qt::ConnectionType connectionType = Qt::AutoConnection) override
|
|
{
|
|
Q_ASSERT(!m_connected);
|
|
|
|
m_connected = true;
|
|
|
|
// Guard against the possibility when either m_emitter or m_target got deleted before
|
|
// the Connection is actually connected.
|
|
if (!m_emitter || !m_target)
|
|
return;
|
|
|
|
m_conn = QObject::connect(m_emitter.data(), m_signal, m_target.data(), m_slot, connectionType);
|
|
Q_ASSERT(m_conn);
|
|
}
|
|
|
|
void disconnect() override
|
|
{
|
|
Q_ASSERT(m_connected);
|
|
|
|
if (m_conn)
|
|
QObject::disconnect(m_conn);
|
|
|
|
m_connected = false;
|
|
}
|
|
|
|
private:
|
|
bool m_connected{false};
|
|
QPointer<Emitter> m_emitter;
|
|
Signal m_signal;
|
|
QPointer<Target> m_target;
|
|
Slot m_slot;
|
|
QMetaObject::Connection m_conn;
|
|
};
|
|
|
|
/**
|
|
* Helper function in order to deduce the template parameters.
|
|
*/
|
|
template<class Signal, class Slot>
|
|
Connection<Signal, Slot>* createConnection(typename detail::ExtractClass<Signal>::type *emitter, Signal signal,
|
|
typename detail::ExtractClass<Slot>::type *target, Slot slot)
|
|
{
|
|
return new Connection<Signal, Slot>(emitter, signal, target, slot);
|
|
}
|
|
|
|
} // namespace LtsUtils
|