#include <qmetaobject_p.h>

Public Types
enum	DisconnectType { DisconnectAll, DisconnectOne }

Static Public Functions
static bool	connect (const QObject sender, int signal_index, const QObject receiver, int method_index_relative, const QMetaObject rmeta=0, int type=0, int types=0)

static bool	disconnect (const QObject sender, int signal_index, const QObject receiver, int method_index, DisconnectType=DisconnectAll)

static bool	disconnectHelper (QObjectPrivate::Connection c, const QObject receiver, int method_index, QMutex *senderMutex, DisconnectType)

static const QMetaObjectPrivate *	get (const QMetaObject *metaobject)

static int	indexOfSignalRelative (const QMetaObject *baseObject, const char name, bool normalizeStringData)
	Same as QMetaObject::indexOfSignal, but the result is the local offset to the base object. More...

static int	indexOfSlotRelative (const QMetaObject *m, const char slot, bool normalizeStringData)

static void	memberIndexes (const QObject obj, const QMetaMethod &member, int signalIndex, int *methodIndex)
	This helper function calculates signal and method index for the given member in the specified class. More...

static int	originalClone (const QMetaObject *obj, int local_method_index)

Public Variables
int	classInfoCount

int	classInfoData

int	className

int	constructorCount

int	constructorData

int	enumeratorCount

int	enumeratorData

int	flags

int	methodCount

int	methodData

int	propertyCount

int	propertyData

int	revision

int	signalCount

Detailed Description

Definition at line 109 of file qmetaobject_p.h.

Enumerations

◆ DisconnectType

enum QMetaObjectPrivate::DisconnectType

Enumerator
DisconnectAll
DisconnectOne

Definition at line 136 of file qmetaobject_p.h.

136 { DisconnectAll, DisconnectOne };

QMetaObjectPrivate::DisconnectAll

Definition: qmetaobject_p.h:136

QMetaObjectPrivate::DisconnectOne

Definition: qmetaobject_p.h:136

Functions

◆ connect()

bool QMetaObjectPrivate::connect	(	const QObject *	sender,
		int	signal_index,
		const QObject *	receiver,
		int	method_index,
		const QMetaObject *	rmeta = `0`,
		int	type = `0`,
		int *	types = `0`
	)

static

Warning: This function is not part of the public interface. Same as the QMetaObject::connect, but signal_index must be the result of QObjectPrivate::signalIndex

method_index is relative to the rmeta metaobject, if rmeta is null, then it is absolute index

Definition at line 3209 of file qobject.cpp.

Referenced by QObject::connect(), QMetaObject::connect(), and QMetaObject::connectSlotsByName().

 {
     QObject *s = const_cast<QObject *>(sender);
     QObject *r = const_cast<QObject *>(receiver);
 
     int method_offset = rmeta ? rmeta->methodOffset() : 0;
     QObjectPrivate::StaticMetaCallFunction callFunction =
         (rmeta && QMetaObjectPrivate::get(rmeta)->revision >= 6 && rmeta->d.extradata)
         ? reinterpret_cast<const QMetaObjectExtraData *>(rmeta->d.extradata)->static_metacall : 0;
 
     QOrderedMutexLocker locker(signalSlotLock(sender),
                                signalSlotLock(receiver));
 
     if (type & Qt::UniqueConnection) {
         QObjectConnectionListVector *connectionLists = QObjectPrivate::get(s)->connectionLists;
         if (connectionLists && connectionLists->count() > signal_index) {
             const QObjectPrivate::Connection *c2 =
                 (*connectionLists)[signal_index].first;
 
             int method_index_absolute = method_index + method_offset;
 
             while (c2) {
                 if (c2->receiver == receiver && c2->method() == method_index_absolute)
                     return false;
                 c2 = c2->nextConnectionList;
             }
         }
         type &= Qt::UniqueConnection - 1;
     }
 
     QObjectPrivate::Connection *c = new QObjectPrivate::Connection;
     c->sender = s;
     c->receiver = r;
     c->method_relative = method_index;
     c->method_offset = method_offset;
     c->connectionType = type;
     c->argumentTypes = types;
     c->nextConnectionList = 0;
     c->callFunction = callFunction;
 
     QT_TRY {
         QObjectPrivate::get(s)->addConnection(signal_index, c);
     } QT_CATCH(...) {
         delete c;
         QT_RETHROW;
     }
 
     c->prev = &(QObjectPrivate::get(r)->senders);
     c->next = *c->prev;
     *c->prev = c;
     if (c->next)
         c->next->prev = &c->next;
 
     QObjectPrivate *const sender_d = QObjectPrivate::get(s);
     if (signal_index < 0) {
         sender_d->connectedSignals[0] = sender_d->connectedSignals[1] = ~0;
     } else if (signal_index < (int)sizeof(sender_d->connectedSignals) * 8) {
         sender_d->connectedSignals[signal_index >> 5] |= (1 << (signal_index & 0x1f));
     }
 
     return true;
 }

◆ disconnect()

bool QMetaObjectPrivate::disconnect	(	const QObject *	sender,
		int	signal_index,
		const QObject *	receiver,
		int	method_index,
		DisconnectType	disconnectType = `DisconnectAll`
	)

static

Warning: This function is not part of the public interface. Same as the QMetaObject::disconnect, but signal_index must be the result of QObjectPrivate::signalIndex

Definition at line 3342 of file qobject.cpp.

Referenced by QObject::disconnect(), QMetaObject::disconnect(), and QMetaObject::disconnectOne().

 {
     if (!sender)
         return false;
 
     QObject *s = const_cast<QObject *>(sender);
 
     QMutex *senderMutex = signalSlotLock(sender);
     QMutex *receiverMutex = receiver ? signalSlotLock(receiver) : 0;
     QOrderedMutexLocker locker(senderMutex, receiverMutex);
 
     QObjectConnectionListVector *connectionLists = QObjectPrivate::get(s)->connectionLists;
     if (!connectionLists)
         return false;
 
     // prevent incoming connections changing the connectionLists while unlocked
     ++connectionLists->inUse;
 
     bool success = false;
     if (signal_index < 0) {
         // remove from all connection lists
         for (signal_index = -1; signal_index < connectionLists->count(); ++signal_index) {
             QObjectPrivate::Connection *c =
                 (*connectionLists)[signal_index].first;
             if (disconnectHelper(c, receiver, method_index, senderMutex, disconnectType)) {
                 success = true;
                 connectionLists->dirty = true;
             }
         }
     } else if (signal_index < connectionLists->count()) {
         QObjectPrivate::Connection *c =
             (*connectionLists)[signal_index].first;
         if (disconnectHelper(c, receiver, method_index, senderMutex, disconnectType)) {
             success = true;
             connectionLists->dirty = true;
         }
     }
 
     --connectionLists->inUse;
     Q_ASSERT(connectionLists->inUse >= 0);
     if (connectionLists->orphaned && !connectionLists->inUse)
         delete connectionLists;
 
     return success;
 }

◆ disconnectHelper()

bool QMetaObjectPrivate::disconnectHelper	(	QObjectPrivate::Connection *	c,
		const QObject *	receiver,
		int	method_index,
		QMutex *	senderMutex,
		DisconnectType	disconnectType
	)

inlinestatic

Warning: This function is not part of the public interface. Helper function to remove the connection from the senders list and setting the receivers to 0

Definition at line 3302 of file qobject.cpp.

 {
     bool success = false;
     while (c) {
         if (c->receiver
             && (receiver == 0 || (c->receiver == receiver
                            && (method_index < 0 || c->method() == method_index)))) {
             bool needToUnlock = false;
             QMutex *receiverMutex = 0;
             if (!receiver) {
                 receiverMutex = signalSlotLock(c->receiver);
                 // need to relock this receiver and sender in the correct order
                 needToUnlock = QOrderedMutexLocker::relock(senderMutex, receiverMutex);
             }
             if (c->receiver) {
                 *c->prev = c->next;
                 if (c->next)
                     c->next->prev = c->prev;
             }
 
             if (needToUnlock)
                 receiverMutex->unlockInline();
 
             c->receiver = 0;
 
             success = true;
 
             if (disconnectType == DisconnectOne)
                 return success;
         }
         c = c->nextConnectionList;
     }
     return success;
 }

◆ get()

static const QMetaObjectPrivate* QMetaObjectPrivate::get ( const QMetaObject * metaobject )

inlinestatic

Definition at line 123 of file qmetaobject_p.h.

Referenced by computeOffsets(), connect(), and QMetaMethod::invoke().

124 { return reinterpret_cast<const QMetaObjectPrivate*>(metaobject->d.data); }

QMetaObject::data

const uint * data

Definition: qobjectdefs.h:471

QMetaObject::d

struct QMetaObject::@38 d

QMetaObjectPrivate

Definition: qmetaobject_p.h:109

◆ indexOfSignalRelative()

int QMetaObjectPrivate::indexOfSignalRelative	(	const QMetaObject **	baseObject,
		const char *	signal,
		bool	normalizeStringData
	)

static

Same as QMetaObject::indexOfSignal, but the result is the local offset to the base object.

Warning: This function is not part of the public interface.

baseObject will be adjusted to the enclosing QMetaObject, or 0 if the signal is not found

Definition at line 648 of file qmetaobject.cpp.

Referenced by QObject::connect(), QObject::disconnect(), get(), QMetaObject::indexOfSignal(), and QObjectPrivate::signalIndex().

 {
     int i = indexOfMethodRelative<MethodSignal>(baseObject, signal, normalizeStringData);
 #ifndef QT_NO_DEBUG
     const QMetaObject *m = *baseObject;
     if (i >= 0 && m && m->d.superdata) {
         int conflict = m->d.superdata->indexOfMethod(signal);
         if (conflict >= 0)
             qWarning("QMetaObject::indexOfSignal: signal %s from %s redefined in %s",
                      signal, m->d.superdata->d.stringdata, m->d.stringdata);
     }
 #endif
     return i;
 }

◆ indexOfSlotRelative()

int QMetaObjectPrivate::indexOfSlotRelative	(	const QMetaObject **	m,
		const char *	slot,
		bool	normalizeStringData
	)

static

Definition at line 685 of file qmetaobject.cpp.

Referenced by QObject::connect(), get(), and QMetaObject::indexOfSlot().

 {
     return indexOfMethodRelative<MethodSlot>(m, slot, normalizeStringData);
 }

◆ memberIndexes()

void QMetaObjectPrivate::memberIndexes	(	const QObject *	obj,
		const QMetaMethod &	member,
		int *	signalIndex,
		int *	methodIndex
	)

static

This helper function calculates signal and method index for the given member in the specified class.

Warning: This function is not part of the public interface.

If member.mobj is 0 then both signalIndex and methodIndex are set to -1.
If specified member is not a member of obj instance class (or one of its parent classes) then both signalIndex and methodIndex are set to -1.

This function is used by QObject::connect and QObject::disconnect which are working with QMetaMethod.

signalIndex is set to the signal index of member. If the member specified is not signal this variable is set to -1.

methodIndex is set to the method index of the member. If the member is not a method of the object specified by the obj argument this variable is set to -1.

Definition at line 2468 of file qobject.cpp.

Referenced by QObject::connect(), and QObject::disconnect().

 {
     *signalIndex = -1;
     *methodIndex = -1;
     if (!obj || !member.mobj)
         return;
     const QMetaObject *m = obj->metaObject();
     // Check that member is member of obj class
     while (m != 0 && m != member.mobj)
         m = m->d.superdata;
     if (!m)
         return;
     *signalIndex = *methodIndex = (member.handle - get(member.mobj)->methodData)/5;
 
     int signalOffset;
     int methodOffset;
     computeOffsets(m, &signalOffset, &methodOffset);
 
     *methodIndex += methodOffset;
     if (member.methodType() == QMetaMethod::Signal) {
         *signalIndex = originalClone(m, *signalIndex);
         *signalIndex += signalOffset;
     } else {
         *signalIndex = -1;
     }
 }

◆ originalClone()

int QMetaObjectPrivate::originalClone	(	const QMetaObject *	mobj,
		int	local_method_index
	)

static

Warning: This function is not part of the public interface. If the local_method_index is a cloned method, return the index of the original.

Example: if the index of "destroyed()" is passed, the index of "destroyed(QObject*)" is returned

Definition at line 2883 of file qmetaobject.cpp.

Referenced by QMetaObject::activate(), QObject::connect(), QObject::disconnect(), get(), methodIndexToSignalIndex(), and QObjectPrivate::signalIndex().

 {
     Q_ASSERT(local_method_index < get(mobj)->methodCount);
     int handle = get(mobj)->methodData + 5 * local_method_index;
     while (mobj->d.data[handle + 4] & MethodCloned) {
         Q_ASSERT(local_method_index > 0);
         handle -= 5;
         local_method_index--;
     }
     return local_method_index;
 }