Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.qt.internal.SignalUtility Maven / Gradle / Ivy
QtJambi base module containing QtCore, QtGui and QtWidgets.
/****************************************************************************
**
** Copyright (C) 2009-2024 Dr. Peter Droste, Omix Visualization GmbH & Co. KG. All rights reserved.
**
** This file is part of Qt Jambi.
**
** $BEGIN_LICENSE$
** GNU Lesser General Public License Usage
** 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.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
** $END_LICENSE$
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
package io.qt.internal;
import java.io.Serializable;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.SerializedLambda;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.logging.Level;
import java.util.logging.Logger;
import io.qt.NativeAccess;
import io.qt.NonNull;
import io.qt.Nullable;
import io.qt.QMisfittingSignatureException;
import io.qt.QNoNativeResourcesException;
import io.qt.QNoSuchSignalException;
import io.qt.QNoSuchSlotException;
import io.qt.QSignalDeclarationException;
import io.qt.QSignalInitializationException;
import io.qt.QSignalInvocationException;
import io.qt.QUninvokableSlotException;
import io.qt.QUnsuccessfulInvocationException;
import io.qt.QtObject;
import io.qt.QtObjectInterface;
import io.qt.QtPointerType;
import io.qt.QtPrimitiveType;
import io.qt.QtReferenceType;
import io.qt.QtSignalBlockerInterface;
import io.qt.QtSignalEmitterInterface;
import io.qt.QtThreadAffineInterface;
import io.qt.QtUninvokable;
import io.qt.QtUtilities;
import io.qt.core.QByteArray;
import io.qt.core.QDeclarableSignals;
import io.qt.core.QEvent;
import io.qt.core.QHash;
import io.qt.core.QInstanceMemberSignals;
import io.qt.core.QList;
import io.qt.core.QMap;
import io.qt.core.QMetaMethod;
import io.qt.core.QMetaObject;
import io.qt.core.QMetaObject.Connection;
import io.qt.core.QMetaObject.GenericSlot;
import io.qt.core.QMetaObject.Slot0;
import io.qt.core.QMetaObject.Slot1;
import io.qt.core.QMetaObject.Slot2;
import io.qt.core.QMetaObject.Slot3;
import io.qt.core.QMetaObject.Slot4;
import io.qt.core.QMetaObject.Slot5;
import io.qt.core.QMetaObject.Slot6;
import io.qt.core.QMetaObject.Slot7;
import io.qt.core.QMetaObject.Slot8;
import io.qt.core.QMetaObject.Slot9;
import io.qt.core.QObject;
import io.qt.core.QPair;
import io.qt.core.QSet;
import io.qt.core.QStaticMemberSignals;
import io.qt.core.QStringList;
import io.qt.core.QThread;
import io.qt.core.Qt;
import io.qt.core.Qt.ConnectionType;
/**
* @hidden
*/
abstract class SignalUtility {
static {
QtJambi_LibraryUtilities.initialize();
}
private final static String wrapper = "Wrapper";
private final static String qvariant = "QVariant";
protected SignalUtility() {throw new RuntimeException();}
private final static java.util.logging.Logger logger = java.util.logging.Logger.getLogger("io.qt.internal");
private static final Map lookupSlots = Collections.synchronizedMap(new HashMap<>());
@NativeAccess
static final class SignalParameterType{
public SignalParameterType(Class type, Type genericType, AnnotatedElement annotatedType, boolean isPointer, boolean isReference) {
super();
this.genericType = genericType;
this.annotatedType = annotatedType;
this.type = type;
if(annotatedType!=null) {
if(!isReference) {
QtReferenceType referenceType = annotatedType.getAnnotation(QtReferenceType.class);
isReference = referenceType!=null && !referenceType.isConst();
}
if(!isPointer) {
QtPointerType pointerType = annotatedType.getAnnotation(QtPointerType.class);
isPointer = pointerType!=null;
}
}
this.isPointer = isPointer;
this.isReference = isReference;
}
@NativeAccess
final Class type;
final Type genericType;
final AnnotatedElement annotatedType;
final boolean isPointer;
final boolean isReference;
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj instanceof SignalParameterType) {
SignalParameterType other = (SignalParameterType) obj;
if(isPointer==other.isPointer
&& isReference==other.isReference) {
if(type==other.type)
return true;
}
return false;
}
return false;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((type == null) ? 0 : type.getName().hashCode());
result = prime * result + (isPointer ? 0 : 1);
result = prime * result + (isReference ? 0 : 1);
return result;
}
}
private interface SlotConnectionFactory{
public SlotObjectConnection create(Reference lambdaOwner, Class lambdaOwnerClass, int lambdaHashCode, Slot slotObject, Qt.ConnectionType[] connectionType);
}
private static abstract class AbstractSignalCore {
abstract QMetaMethod signalMethod(AbstractSignal signal);
abstract List signalTypes(AbstractSignal signal);
abstract String name(AbstractSignal signal);
abstract String fullName(AbstractSignal signal);
abstract boolean isConnected(AbstractSignal signal);
abstract int receivers(AbstractSignal signal);
abstract void emitSignal(AbstractSignal signal, final Object[] args, Supplier... suppliers);
abstract QMetaObject.Connection addConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, MethodHandle slotHandle, LambdaArgsProvider lambdaArgs, Qt.ConnectionType[] connectionType);
abstract QMetaObject.Connection addConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot, Qt.ConnectionType[] connectionType);
abstract QMetaObject.Connection addConnectionToSlotObject(AbstractSignal signal, SlotConnectionFactory factory, Object lambdaOwner, Class lambdaOwnerClass, int lambdaHash, Slot slotObject, Qt.ConnectionType[] connectionType);
abstract boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, Object[] lambdaArgs, boolean allowNativeDisconnect);
abstract boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot, boolean allowNativeDisconnect);
int methodIndex(AbstractSignal signal) { return -1; }
Class getDeclaringClass(AbstractSignal signal){ return null; }
abstract boolean removeConnectionToSlotObject(AbstractSignal signal,
Serializable slotObject, Class _functionalInterfaceClass, Object _lambdaOwner, Class _lambdaOwnerClass,
int _lambdaHashCode, boolean useLambdaInfo);
abstract boolean removeConnection(AbstractSignal signal, LightweightConnection javaConnection);
abstract boolean removeConnection(AbstractSignal signal, NativeConnection nativeConnection);
String toString(AbstractSignal signal) {
return String.format("%1$s(%2$s)", signal.name(), signal.signalParameters());
}
abstract boolean isStaticSignal(AbstractSignal signal);
abstract boolean isQObjectSignal(AbstractSignal signal);
}
private interface AnalyzingSignalCoreInterface{
}
private static class AnalyzingSignalCore extends AbstractSignalCore implements AnalyzingSignalCoreInterface{
final static AnalyzingSignalCore instance = new AnalyzingSignalCore();
@Override
final QMetaMethod signalMethod(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.signalMethod(signal);
}
@Override
final List signalTypes(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.signalTypes(signal);
}
@Override
final String name(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.name(signal);
}
@Override
final String fullName(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.fullName(signal);
}
@Override
final boolean isConnected(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.isConnected(signal);
}
@Override
final int receivers(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.receivers(signal);
}
@Override
final boolean isStaticSignal(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.isStaticSignal(signal);
}
@Override
final boolean isQObjectSignal(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.isQObjectSignal(signal);
}
@Override
final Connection addConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, MethodHandle slotHandle,
LambdaArgsProvider lambdaArgs, ConnectionType[] connectionType) {
signal.resolveSignal();
return signal.core.addConnectionToMethod(signal, receiver, slot, slotHandle, lambdaArgs, connectionType);
}
@Override
final QMetaObject.Connection addConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot, Qt.ConnectionType[] connectionType){
signal.resolveSignal();
return signal.core.addConnectionToMethod(signal, receiver, slot, connectionType);
}
@Override
final void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
signal.resolveSignal();
signal.core.emitSignal(signal, args, suppliers);
}
@Override
final Connection addConnectionToSlotObject(AbstractSignal signal,
SlotConnectionFactory factory, Object lambdaOwner, Class lambdaOwnerClass, int lambdaHash, Slot slotObject, ConnectionType[] connectionType) {
signal.resolveSignal();
return signal.core.addConnectionToSlotObject(signal, factory, lambdaOwner, lambdaOwnerClass, lambdaHash, slotObject, connectionType);
}
final int methodIndex(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.methodIndex(signal);
}
@Override
final boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, Object[] lambdaArgs,
boolean allowNativeDisconnect) {
signal.resolveSignal();
return signal.core.removeConnectionToMethod(signal, receiver, slot, lambdaArgs, allowNativeDisconnect);
}
@Override
final boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot, boolean allowNativeDisconnect) {
signal.resolveSignal();
return signal.core.removeConnectionToMethod(signal, receiver, slot, allowNativeDisconnect);
}
@Override
final boolean removeConnectionToSlotObject(AbstractSignal signal,
Serializable slotObject, Class _functionalInterfaceClass, Object _lambdaOwner, Class _lambdaOwnerClass,
int _lambdaHashCode, boolean useLambdaInfo) {
signal.resolveSignal();
return signal.core.removeConnectionToSlotObject(signal, slotObject, _functionalInterfaceClass, _lambdaOwner, _lambdaOwnerClass, _lambdaHashCode, useLambdaInfo);
}
@Override
final boolean removeConnection(AbstractSignal signal, LightweightConnection javaConnection) {
signal.resolveSignal();
return signal.core.removeConnection(signal, javaConnection);
}
@Override
final boolean removeConnection(AbstractSignal signal, NativeConnection nativeConnection) {
signal.resolveSignal();
return signal.core.removeConnection(signal, nativeConnection);
}
final Class getDeclaringClass(AbstractSignal signal){
signal.resolveSignal();
return signal.core.getDeclaringClass(signal);
}
final String toString(AbstractSignal signal) {
signal.resolveSignal();
return signal.core.toString(signal);
}
}
private static class AnalyzingCheckingSignalCore extends AnalyzingSignalCore{
private final Consumer argumentTest;
private AnalyzingCheckingSignalCore(Consumer argumentTest) {
this.argumentTest = Objects.requireNonNull(argumentTest);
}
final static Function,AnalyzingSignalCore> FACTORY;
static {
if(Boolean.getBoolean("io.qt.enable-signal-argument-check")) {
FACTORY = AnalyzingCheckingSignalCore::new;
}else {
FACTORY = argumentTest->AnalyzingSignalCore.instance;
}
}
}
private static class AnalyzingStaticSignalCore extends AnalyzingSignalCore{
private final Class declaringClass;
AnalyzingStaticSignalCore(Class declaringClass) {
this.declaringClass = declaringClass;
}
Class declaringClass() {
return declaringClass;
}
}
private abstract static class AbstractParameterSignalCore extends AbstractSignalCore {
private final List signalParameterTypes;
public AbstractParameterSignalCore(List signalParameterTypes) {
super();
this.signalParameterTypes = signalParameterTypes;
}
@Override
List signalTypes(AbstractSignal signal) {
return signalParameterTypes;
}
private String signalParameters() {
List args = new ArrayList<>();
for (SignalParameterType type : signalParameterTypes) {
if(type.genericType!=null)
args.add(type.genericType.getTypeName());
else
args.add(type.type.getName());
}
return String.join(", ", args);
}
abstract String name();
@Override
public String toString() {
return String.format("%1$s(%2$s)", name(), signalParameters());
}
@Override
String toString(AbstractSignal signal) {
return toString();
}
}
private static class QObjectsNativeSignalCore extends AbstractParameterSignalCore {
public QObjectsNativeSignalCore(List signalParameterTypes, final int methodIndex, final long metaObjectId) {
super(signalParameterTypes);
assert methodIndex>=0;
assert metaObjectId!=0;
this.methodIndex = methodIndex;
this.metaObjectId = metaObjectId;
}
final int methodIndex;
final long metaObjectId;
@Override
final boolean isStaticSignal(AbstractSignal signal) {
return false;
}
@Override
final boolean isQObjectSignal(AbstractSignal signal) {
return true;
}
@Override
final QMetaMethod signalMethod(AbstractSignal signal) {
return SignalUtility.signalMethod(methodIndex, metaObjectId);
}
String toString(AbstractSignal signal) {
if(methodIndex>=0 && metaObjectId!=0)
return signalSignature(methodIndex, metaObjectId);
return super.toString(signal);
}
@Override
final String name() {
if(methodIndex>=0 && metaObjectId!=0)
return signalName(methodIndex, metaObjectId);
return null;
}
@Override
final String name(AbstractSignal signal) {
return name();
}
@Override
final String fullName(AbstractSignal signal) {
QMetaMethod mtd = signalMethod(signal);
if(mtd!=null && mtd.isValid())
return mtd.enclosingMetaObject().type().getName()+"."+mtd.name();
return "()";
}
@Override
final int methodIndex(AbstractSignal signal) { return methodIndex; }
@Override
final Connection addConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot,
ConnectionType[] connectionType) {
QObject senderObject = (QObject)signal.containingObject();
int flags = 0;
if(connectionType!=null && connectionType.length>0) {
for (Qt.ConnectionType ct : connectionType) {
flags |= ct.value();
}
}
if(receiver instanceof QObject) {
return connectNativeToMetaMethod(NativeUtility.checkedNativeId(senderObject), methodIndex, metaObjectId, NativeUtility.checkedNativeId((QObject)receiver), NativeUtility.checkedNativeId(slot), flags);
}else {
NativeUtility.FinalizerReference cleanable;
MetaMethodConnection c;
if(receiver instanceof QtObjectInterface){
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtObjectInterface)receiver);
cleanable = reference;
c = new QtInstanceMetaMethodConnection(new WeakReference<>((QtObjectInterface)receiver), slot, connectionType);
}else {
c = new MetaMethodConnection<>(cleanable = new NativeUtility.FinalizerReference<>(receiver), slot, connectionType);
}
QMetaObject.Connection connection = connectNative(NativeUtility.checkedNativeId(senderObject), methodIndex, metaObjectId, 0, c, slot.parameterTypes().size(), flags);
if(connection.isConnected()) {
SignalUtility.NativeConnection nativeConnection = (SignalUtility.NativeConnection)connection.clone();
cleanable.setFinally(()->{
disconnectConnection(NativeUtility.nativeId(nativeConnection));
});
}
return connection;
}
}
@Override
final Connection addConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, MethodHandle slotHandle,
LambdaArgsProvider lambdaArgs, ConnectionType[] connectionType) {
QObject senderObject = (QObject)signal.containingObject();
int flags = 0;
if(connectionType!=null && connectionType.length>0) {
for (Qt.ConnectionType ct : connectionType) {
flags |= ct.value();
}
}
if(lambdaArgs==null
&& (receiver instanceof QObject ||
( receiver instanceof QMetaObject.AbstractSignal
&& slot.getName().equals("emit")
&& ((AbstractSignal)receiver).methodIndex()>=0
&& ((AbstractSignal)receiver).containingObject() instanceof QObject) )) {
QObject receiverObject;
QMetaMethod slotMethod = null;
if(receiver instanceof QObject) {
receiverObject = (QObject)receiver;
slotMethod = QMetaMethod.fromReflectedMethod(slot);
}else {
AbstractSignal otherSignal = (AbstractSignal)receiver;
receiverObject = (QObject)otherSignal.containingObject();
slotMethod = otherSignal.signalMethod();
}
if(slotMethod!=null && slotMethod.isValid()) {
try{
return connectNativeToMetaMethod(NativeUtility.checkedNativeId(senderObject), methodIndex, metaObjectId, NativeUtility.checkedNativeId(receiverObject), NativeUtility.checkedNativeId(slotMethod), flags);
} catch (QMisfittingSignatureException e) {
}
}
}
if(slotHandle==null){
try{
slotHandle = ReflectionUtility.privateLookup(slot.getDeclaringClass()).unreflect(slot);
if(slotHandle.isVarargsCollector()) {
slotHandle = slotHandle.asFixedArity();
}
} catch (Throwable e2) {
logger.log(java.util.logging.Level.WARNING, "Exception caught while analyzing slot "+slot, e2);
return new NonConnection();
}
}
if(Modifier.isStatic(slot.getModifiers())/* && !(slot.isSynthetic() && receiver!=null)*/) {
AbstractReflectiveConnection conn;
if(lambdaArgs==null){
StaticSlotInvoker invoker = ReflectionUtility.getStaticSlotInvoker(slot, slotHandle);
if(invoker==null) {
conn = new StaticReflectiveConnection(slot, connectionType);
}else {
conn = new StaticInvokerConnection(invoker, slot, connectionType);
}
}else {
StaticLambdaArgsSlotInvoker invoker = ReflectionUtility.getStaticSlotInvoker(slot, slotHandle, lambdaArgs.size());
if(invoker==null) {
conn = new StaticLambdaArgsReflectiveConnection(slot, lambdaArgs, connectionType);
}else {
conn = new StaticLambdaArgsInvokerConnection(invoker, slot, lambdaArgs, connectionType);
}
}
return connectNative(NativeUtility.checkedNativeId(senderObject), methodIndex, metaObjectId, 0, conn,
slot.getParameterCount()-(lambdaArgs==null ? 0 : lambdaArgs.size()), flags);
}else {
AbstractReflectiveConnection conn;
long receiverId = 0;
NativeUtility.FinalizerReference cleanable = null;
if(lambdaArgs==null){
SlotInvoker invoker = ReflectionUtility.getSlotInvoker(slot, slotHandle);
if(invoker==null) {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QObject) {
receiverId = NativeUtility.checkedNativeId((QObject)receiver);
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QObject)receiver);
cleanable = reference;
if(isDirect(flags))
conn = new QObjectDirectReflectiveConnection(reference, slot, connectionType);
else
conn = new QObjectReflectiveConnection(reference, slot, connectionType);
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(flags)){
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtObjectInterface)receiver);
cleanable = reference;
conn = new QtInstanceThreadAffineReflectiveConnection(reference, slot, connectionType);
}else {
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtObjectInterface)receiver);
cleanable = reference;
conn = new QtInstanceReflectiveConnection(reference, slot, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(flags)){
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtThreadAffineInterface)receiver);
cleanable = reference;
conn = new ThreadAffineReflectiveConnection(reference, slot, connectionType);
}else {
conn = new ReflectiveConnection<>(cleanable = new NativeUtility.FinalizerReference<>(receiver), slot, connectionType);
}
}else {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QObject) {
receiverId = NativeUtility.checkedNativeId((QObject)receiver);
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QObject)receiver);
cleanable = reference;
if(isDirect(flags))
conn = new QObjectDirectInvokerConnection(reference, invoker, slot, connectionType);
else
conn = new QObjectInvokerConnection(reference, invoker, slot, connectionType);
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(flags)){
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtObjectInterface)receiver);
cleanable = reference;
conn = new QtInstanceThreadAffineInvokerConnection(reference, invoker, slot, connectionType);
}else {
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtObjectInterface)receiver);
cleanable = reference;
conn = new QtInstanceInvokerConnection(reference, invoker, slot, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(flags)){
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtThreadAffineInterface)receiver);
cleanable = reference;
conn = new ThreadAffineInvokerConnection(reference, invoker, slot, connectionType);
}else {
conn = new InvokerConnection<>(cleanable = new NativeUtility.FinalizerReference<>(receiver), invoker, slot, connectionType);
}
}
}else {
LambdaArgsSlotInvoker invoker = ReflectionUtility.getSlotInvoker(slot, slotHandle, lambdaArgs.size());
if(invoker==null) {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QObject) {
receiverId = NativeUtility.checkedNativeId((QObject)receiver);
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QObject)receiver);
cleanable = reference;
if(isDirect(flags))
conn = new QObjectLambdaArgsDirectReflectiveConnection(reference, slot, lambdaArgs, connectionType);
else
conn = new QObjectLambdaArgsReflectiveConnection(reference, slot, lambdaArgs, connectionType);
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(flags)){
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtObjectInterface)receiver);
cleanable = reference;
conn = new QtInstanceThreadAffineLambdaArgsReflectiveConnection(reference, slot, lambdaArgs, connectionType);
}else {
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtObjectInterface)receiver);
cleanable = reference;
conn = new QtInstanceLambdaArgsReflectiveConnection(reference, slot, lambdaArgs, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(flags)){
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtThreadAffineInterface)receiver);
cleanable = reference;
conn = new ThreadAffineLambdaArgsReflectiveConnection(reference, slot, lambdaArgs, connectionType);
}else {
conn = new LambdaArgsReflectiveConnection<>(cleanable = new NativeUtility.FinalizerReference<>(receiver), slot, lambdaArgs, connectionType);
}
}else {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QObject) {
receiverId = NativeUtility.checkedNativeId((QObject)receiver);
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QObject)receiver);
cleanable = reference;
if(isDirect(flags))
conn = new QObjectLambdaArgsDirectInvokerConnection(reference, invoker, slot, lambdaArgs, connectionType);
else
conn = new QObjectLambdaArgsInvokerConnection(reference, invoker, slot, lambdaArgs, connectionType);
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(flags)){
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtObjectInterface)receiver);
cleanable = reference;
conn = new QtInstanceThreadAffineLambdaArgsInvokerConnection(reference, invoker, slot, lambdaArgs, connectionType);
}else {
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtObjectInterface)receiver);
cleanable = reference;
conn = new QtInstanceLambdaArgsInvokerConnection(reference, invoker, slot, lambdaArgs, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(flags)){
NativeUtility.FinalizerReference reference = new NativeUtility.FinalizerReference<>((QtThreadAffineInterface)receiver);
cleanable = reference;
conn = new ThreadAffineLambdaArgsInvokerConnection(reference, invoker, slot, lambdaArgs, connectionType);
}else {
conn = new LambdaArgsInvokerConnection<>(cleanable = new NativeUtility.FinalizerReference<>(receiver), invoker, slot, lambdaArgs, connectionType);
}
}
}
QMetaObject.Connection connection = connectNative(NativeUtility.checkedNativeId(senderObject), methodIndex, metaObjectId, receiverId,
conn, slot.getParameterCount()-(lambdaArgs==null ? 0 : lambdaArgs.size()), flags);
if(connection.isConnected() && cleanable!=null) {
SignalUtility.NativeConnection nativeConnection = (SignalUtility.NativeConnection)connection.clone();
cleanable.setFinally(()->{
disconnectConnection(NativeUtility.nativeId(nativeConnection));
});
}
return connection;
}
}
@Override
final Connection addConnectionToSlotObject(AbstractSignal signal,
SlotConnectionFactory factory, Object context, Class lambdaOwnerClass, int lambdaHashCode, Slot slotObject, ConnectionType[] connectionType) {
QObject senderObject = (QObject)signal.containingObject();
int flags = 0;
if(connectionType!=null && connectionType.length>0) {
for (Qt.ConnectionType ct : connectionType) {
flags |= ct.value();
}
}
SlotObjectConnection c = factory.create(new WeakReference(context), lambdaOwnerClass, lambdaHashCode, slotObject, connectionType);
return connectNative(NativeUtility.checkedNativeId(senderObject),
methodIndex, metaObjectId,
context instanceof QObject ? NativeUtility.checkedNativeId((QObject)context) : 0,
c, -1, flags);
}
@Override
final boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot, boolean allowNativeDisconnect) {
QObject senderObject = (QObject)signal.containingObject();
if(senderObject==null || senderObject.isDisposed())
return false;
final long senderObjectId = NativeUtility.checkedNativeId(senderObject);
boolean success = false;
if(((receiver == null || receiver instanceof QObject) && slot == null)
|| (receiver instanceof QObject && slot != null)) {
success |= disconnectNative(senderObjectId, methodIndex, metaObjectId, NativeUtility.nativeId((QObject)receiver), NativeUtility.nativeId(slot));
}
success |= disconnectNative(senderObjectId, methodIndex, metaObjectId, c->{
if(c instanceof MetaMethodConnection) {
MetaMethodConnection rc = (MetaMethodConnection)c;
if(receiver == null) {
if(slot == null) {
return true;
}else if(rc.slot.equals(slot)){
return true;
}
}else if(rc.resolveReceiver() == receiver){
if(slot == null) {
return true;
}else if(rc.slot.equals(slot)){
return true;
}
}
}
return false;
});
return success;
}
@Override
final boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, Object[] lambdaArgs, boolean allowNativeDisconnect) {
QObject senderObject = (QObject)signal.containingObject();
if(senderObject==null || senderObject.isDisposed())
return false;
final long senderObjectId = NativeUtility.checkedNativeId(senderObject);
boolean success = false;
if((receiver == null || receiver instanceof QObject) && slot == null) {
success |= disconnectNative(senderObjectId, methodIndex, metaObjectId, NativeUtility.nativeId((QObject)receiver), 0);
}
if(receiver instanceof QObject ||
( receiver instanceof QMetaObject.AbstractSignal
&& slot!=null
&& slot.getName().equals("emit")
&& ((AbstractSignal)receiver).methodIndex()>=0
&& ((AbstractSignal)receiver).isQObjectSignal()) ) {
QObject receiverObject;
QMetaMethod slotMethod = null;
if(receiver instanceof QObject) {
receiverObject = (QObject)receiver;
if(slot!=null) {
slotMethod = QMetaMethod.fromReflectedMethod(slot);
}
}else {
AbstractSignal otherSignal = (AbstractSignal)receiver;
receiverObject = (QObject)otherSignal.containingObject();
if(otherSignal.methodIndex()>=0) {
slotMethod = otherSignal.signalMethod();
}
}
if(slotMethod!=null)
success |= disconnectNative(senderObjectId, methodIndex, metaObjectId, NativeUtility.checkedNativeId(receiverObject), NativeUtility.checkedNativeId(slotMethod));
}
success |= disconnectNative(senderObjectId, methodIndex, metaObjectId, c->{
if(c instanceof AbstractReflectiveConnection) {
AbstractReflectiveConnection rc = (AbstractReflectiveConnection)c;
if(receiver == null) {
if(slot == null) {
return true;
}else if(rc.slot.equals(slot)){
boolean isLambdaArgsEquals = true;
if(rc.lambdaArgs()!=null && lambdaArgs!=null) {
Object[] _lambdaArgs;
try{
_lambdaArgs = rc.lambdaArgs().lambdaArgs();
}catch(LambdaArgumentGoneException e) {
return false;
}
if(lambdaArgs.length!=_lambdaArgs.length) {
isLambdaArgsEquals = false;
}else {
for (int i = 0; i < lambdaArgs.length; i++) {
if(!Objects.equals(_lambdaArgs[i], lambdaArgs[i])) {
isLambdaArgsEquals = false;
break;
}
}
}
}
return isLambdaArgsEquals;
}
}else if(rc.resolveReceiver() == receiver){
if(slot == null) {
return true;
}else if(rc.slot.equals(slot)){
boolean isLambdaArgsEquals = true;
if(rc.lambdaArgs()!=null && lambdaArgs!=null) {
Object[] _lambdaArgs;
try{
_lambdaArgs = rc.lambdaArgs().lambdaArgs();
}catch(LambdaArgumentGoneException e) {
return false;
}
if(lambdaArgs.length!=_lambdaArgs.length) {
isLambdaArgsEquals = false;
}else {
for (int i = 0; i < lambdaArgs.length; i++) {
if(!Objects.equals(_lambdaArgs[i], lambdaArgs[i])) {
isLambdaArgsEquals = false;
break;
}
}
}
}
return isLambdaArgsEquals;
}
}
}
return false;
});
return success;
}
final boolean removeConnectionToSlotObject(AbstractSignal signal,
Serializable slotObject, Class _functionalInterfaceClass, Object _lambdaOwner, Class _lambdaOwnerClass,
int _lambdaHashCode, boolean useLambdaInfo) {
QObject senderObject = (QObject)signal.containingObject();
if(senderObject==null || senderObject.isDisposed())
return false;
final long senderObjectId = NativeUtility.checkedNativeId(senderObject);
boolean success = false;
success |= disconnectNative(senderObjectId, methodIndex, metaObjectId, c->{
if(c instanceof SlotObjectConnection) {
SlotObjectConnection sc = (SlotObjectConnection)c;
if(sc.slotObject() == slotObject)
return true;
}
return false;
});
return success;
}
@Override
final boolean removeConnection(AbstractSignal signal, LightweightConnection javaConnection) {
return false;
};
@Override
final boolean removeConnection(AbstractSignal signal, NativeConnection nativeConnection) {
return disconnectConnection(NativeUtility.nativeId(nativeConnection));
}
@Override
final boolean isConnected(AbstractSignal signal) {
QObject senderObject = (QObject)signal.containingObject();
if(senderObject==null || senderObject.isDisposed())
return false;
return isSignalConnected(NativeUtility.nativeId(senderObject), methodIndex, metaObjectId);
}
@Override
final int receivers(AbstractSignal signal) {
QObject senderObject = (QObject)signal.containingObject();
if(senderObject==null || senderObject.isDisposed())
return 0;
return signalReceivers(NativeUtility.nativeId(senderObject), methodIndex, metaObjectId);
}
Class getDeclaringClass(AbstractSignal signal){
return null;
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QObject senderObject = (QObject)signal.containingObject();
logger.finest(()->String.format("Emit native signal %1$s", signalSignature(methodIndex, metaObjectId)));
emitSignal(senderObject, args, args, suppliers.length);
}
void emitSignal(QObject senderObject, Object[] originalArgs, Object[] args, int suppliers) {
emitNativeSignal(NativeUtility.checkedNativeId(senderObject), this.methodIndex, this.metaObjectId, suppliers, args);
}
}
private static class QObjectsSignalCore extends QObjectsNativeSignalCore {
public QObjectsSignalCore(List signalParameterTypes, int methodIndex, long metaObjectId) {
super(signalParameterTypes, methodIndex, metaObjectId);
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
assert this.methodIndex>=0;
QObject senderObject = (QObject)signal.containingObject();
logger.finest(()->String.format("Emit native signal %1$s", signalSignature(methodIndex, metaObjectId)));
Object[] originalArgs = args;
if(suppliers.length>0) {
int offset = args.length;
args = Arrays.copyOf(args, args.length+suppliers.length);
for (int i = 0; i < suppliers.length; i++) {
Supplier supplier = suppliers[i];
args[offset+i] = supplier==null ? null : supplier.get();
}
}
emitSignal(senderObject, originalArgs, args, 0);
}
}
private static class QObjectsPrivateNativeSignalCore extends QObjectsNativeSignalCore {
public QObjectsPrivateNativeSignalCore(Class declaringClass,
List signalParameterTypes, int methodIndex, long metaObjectId) {
super(signalParameterTypes, methodIndex, metaObjectId);
this.declaringClass = declaringClass;
}
private final Class declaringClass;
Class getDeclaringClass(AbstractSignal signal){
return declaringClass;
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
throw new RuntimeException(signal.fullName()+".emit()");
}
}
private static class QObjectsPrivateSignalCore extends QObjectsSignalCore {
public QObjectsPrivateSignalCore(Class declaringClass,
List signalParameterTypes, int methodIndex, long metaObjectId) {
super(signalParameterTypes, methodIndex, metaObjectId);
this.declaringClass = declaringClass;
}
private final Class declaringClass;
Class getDeclaringClass(AbstractSignal signal){
return declaringClass;
}
}
private static class QObjectsCheckingNativeSignalCore extends QObjectsNativeSignalCore {
private final Consumer argumentTest;
public QObjectsCheckingNativeSignalCore(List signalParameterTypes, int methodIndex, long metaObjectId, Consumer argumentTest) {
super(signalParameterTypes, methodIndex, metaObjectId);
this.argumentTest = argumentTest;
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QObject senderObject = (QObject)signal.containingObject();
logger.finest(()->String.format("Emit native signal %1$s", signalSignature(methodIndex, metaObjectId)));
if(suppliers.length>0) {
Object[] args2 = Arrays.copyOf(args, args.length + suppliers.length);
for(int i=0; i argumentTest;
public QObjectsCheckingSignalCore(List signalParameterTypes, int methodIndex, long metaObjectId, Consumer argumentTest) {
super(signalParameterTypes, methodIndex, metaObjectId);
this.argumentTest = argumentTest;
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QObject senderObject = (QObject)signal.containingObject();
logger.finest(()->String.format("Emit native signal %1$s", signalSignature(methodIndex, metaObjectId)));
if(suppliers.length>0) {
Object[] args2 = Arrays.copyOf(args, args.length + suppliers.length);
for(int i=0; i declaringClass,
List signalParameterTypes, int methodIndex, long metaObjectId, Consumer argumentTest) {
super(signalParameterTypes, methodIndex, metaObjectId, argumentTest);
this.declaringClass = declaringClass;
}
private final Class declaringClass;
Class getDeclaringClass(AbstractSignal signal){
return declaringClass;
}
}
private static final class MultiSignalAnalyingSignalCore extends AbstractSignalCore implements AnalyzingSignalCoreInterface{
final AbstractMultiSignal multiSignal;
final Class[] types;
public MultiSignalAnalyingSignalCore(AbstractMultiSignal multiSignal, Class[] types) {
super();
this.multiSignal = multiSignal;
this.types = types;
}
@Override
final QMetaMethod signalMethod(AbstractSignal signal) {
multiSignal.resolveMultiSignal();
return signal.core.signalMethod(signal);
}
@Override
List signalTypes(AbstractSignal signal) {
multiSignal.resolveMultiSignal();
return signal.core.signalTypes(signal);
}
@Override
String name(AbstractSignal signal) {
return multiSignal.name();
}
@Override
String fullName(AbstractSignal signal) {
multiSignal.resolveMultiSignal();
return signal.core.fullName(signal);
}
@Override
final boolean isConnected(AbstractSignal signal) {
multiSignal.resolveMultiSignal();
return signal.core.isConnected(signal);
}
@Override
final int receivers(AbstractSignal signal) {
multiSignal.resolveMultiSignal();
return signal.core.receivers(signal);
}
int methodIndex(AbstractSignal signal) {
multiSignal.resolveMultiSignal();
return signal.core.methodIndex(signal);
}
@Override
Connection addConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, MethodHandle slotHandle,
LambdaArgsProvider lambdaArgs, ConnectionType[] connectionType) {
multiSignal.resolveMultiSignal();
return signal.core.addConnectionToMethod(signal, receiver, slot, slotHandle, lambdaArgs, connectionType);
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
multiSignal.resolveMultiSignal();
signal.core.emitSignal(signal, args, suppliers);
}
@Override
Connection addConnectionToSlotObject(AbstractSignal signal,
SlotConnectionFactory factory, Object lambdaOwner, Class lambdaOwnerClass, int lambdaHash, Slot slotObject, ConnectionType[] connectionType) {
multiSignal.resolveMultiSignal();
return signal.core.addConnectionToSlotObject(signal, factory, lambdaOwner, lambdaOwnerClass, lambdaHash, slotObject, connectionType);
}
@Override
boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, Object[] lambdaArgs,
boolean allowNativeDisconnect) {
multiSignal.resolveMultiSignal();
return signal.core.removeConnectionToMethod(signal, receiver, slot, lambdaArgs, allowNativeDisconnect);
}
@Override
boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot, boolean allowNativeDisconnect) {
multiSignal.resolveMultiSignal();
return signal.core.removeConnectionToMethod(signal, receiver, slot, allowNativeDisconnect);
}
boolean removeConnectionToSlotObject(AbstractSignal signal,
Serializable slotObject, Class _functionalInterfaceClass, Object _lambdaOwner, Class _lambdaOwnerClass,
int _lambdaHashCode, boolean useLambdaInfo) {
multiSignal.resolveMultiSignal();
return signal.core.removeConnectionToSlotObject(signal, slotObject, _functionalInterfaceClass, _lambdaOwner, _lambdaOwnerClass, _lambdaHashCode, useLambdaInfo);
}
@Override
boolean removeConnection(AbstractSignal signal, LightweightConnection javaConnection) {
multiSignal.resolveMultiSignal();
return signal.core.removeConnection(signal, javaConnection);
}
@Override
boolean removeConnection(AbstractSignal signal, NativeConnection nativeConnection) {
multiSignal.resolveMultiSignal();
return signal.core.removeConnection(signal, nativeConnection);
}
@Override
Connection addConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot, ConnectionType[] connectionType) {
multiSignal.resolveMultiSignal();
return signal.core.addConnectionToMethod(signal, receiver, slot, connectionType);
}
final Class getDeclaringClass(AbstractSignal signal){
multiSignal.resolveMultiSignal();
return signal.core.getDeclaringClass(signal);
}
final String toString(AbstractSignal signal) {
multiSignal.resolveMultiSignal();
return signal.core.toString(signal);
}
@Override
boolean isStaticSignal(AbstractSignal signal) {
multiSignal.resolveMultiSignal();
return signal.core.isStaticSignal(signal);
}
@Override
boolean isQObjectSignal(AbstractSignal signal) {
multiSignal.resolveMultiSignal();
return signal.core.isQObjectSignal(signal);
}
}
private static class LeightweightSignalCore extends AbstractParameterSignalCore {
public LeightweightSignalCore(Class declaringClass, String name, List signalParameterTypes) {
super(signalParameterTypes);
this.name = name;
this.declaringClass = Objects.requireNonNull(declaringClass);
}
LeightweightSignalCore(String name, List signalParameterTypes) {
super(signalParameterTypes);
this.name = name;
this.declaringClass = null;
}
private final Class declaringClass;
private final String name;
private int currentConnectionId = 0;
private AbstractConnection firstConnection;
private AbstractConnection lastConnection;
private ReentrantReadWriteLock connectionsLock = new ReentrantReadWriteLock();
@Override
boolean isStaticSignal(AbstractSignal signal) {
return false;
}
@Override
final boolean isQObjectSignal(AbstractSignal signal) {
return false;
}
AbstractConnection next(AbstractConnection current){
connectionsLock.readLock().lock();
AbstractConnection next = current.next;
connectionsLock.readLock().unlock();
return next;
}
@Override
final String name() {
return name;
}
@Override
final String name(AbstractSignal signal) {
return name();
}
@Override
String fullName(AbstractSignal signal) {
return declaringClass.getName() + "." + name;
}
Class getDeclaringClass(AbstractSignal signal){
return declaringClass;
}
@Override
final QMetaMethod signalMethod(AbstractSignal signal) {
return new QMetaMethod();
}
@Override
final boolean isConnected(AbstractSignal signal) {
return begin()!=null;
}
@Override
final int receivers(AbstractSignal signal) {
int receivers = 0;
connectionsLock.readLock().lock();
int highestConnectionId = lastConnection==null ? 0 : lastConnection.id;
AbstractConnection currentConnection = firstConnection;
while(currentConnection!=null && currentConnection.id<=highestConnectionId){
if(currentConnection.isConnected() && currentConnection.receiverAvailable())
++receivers;
currentConnection = next(currentConnection);
}
connectionsLock.readLock().unlock();
return receivers;
}
AbstractConnection begin(){
connectionsLock.readLock().lock();
AbstractConnection next = firstConnection;
connectionsLock.readLock().unlock();
return next;
}
AbstractConnection eraseAndNext(AbstractConnection current){
connectionsLock.writeLock().lock();
current.setDisconnected();
if(current==firstConnection) {
if(current.next==null) {
firstConnection = null;
lastConnection = null;
current = null;
}else {
firstConnection = current.next;
current = current.next;
}
}else {
current.previous.next = current.next;
if(current.next==null) {
lastConnection = current.previous;
}else {
current.next.previous = current.previous;
}
current= current.next;
}
connectionsLock.writeLock().unlock();
return current;
}
private void addConnection(AbstractConnection connection) {
connectionsLock.writeLock().lock();
try{
connection.id = ++currentConnectionId;
if(firstConnection==null) {
firstConnection = connection;
lastConnection = connection;
}else {
connection.previous = lastConnection;
lastConnection.next = connection;
lastConnection = connection;
}
}finally {
connectionsLock.writeLock().unlock();
}
}
void disconnectAll() {
connectionsLock.writeLock().lock();
int highestConnectionId = lastConnection==null ? 0 : lastConnection.id;
AbstractConnection currentConnection = firstConnection;
while(currentConnection!=null && currentConnection.id<=highestConnectionId){
currentConnection.setDisconnected();
if(currentConnection==firstConnection) {
if(currentConnection.next==null) {
firstConnection = null;
lastConnection = null;
currentConnection = null;
}else {
firstConnection = currentConnection.next;
currentConnection = currentConnection.next;
}
}else {
currentConnection.previous.next = currentConnection.next;
if(currentConnection.next==null) {
lastConnection = currentConnection.previous;
}else {
currentConnection.next.previous = currentConnection.previous;
}
currentConnection = currentConnection.next;
}
}
connectionsLock.writeLock().unlock();
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
emitSignal(signal, args, suppliers, null, null);
}
void emitSignal(AbstractSignal signal, Object[] args, Supplier[] suppliers, Emitter senderObject, QThread currentThread) {
if(suppliers.length>0) {
int offset = args.length;
args = Arrays.copyOf(args, args.length+suppliers.length);
for (int i = 0; i < suppliers.length; i++) {
Supplier supplier = suppliers[i];
args[offset+i] = supplier==null ? null : supplier.get();
}
}
connectionsLock.readLock().lock();
AbstractConnection currentConnection = firstConnection;
int highestConnectionId = lastConnection==null ? 0 : lastConnection.id;
connectionsLock.readLock().unlock();
while(currentConnection!=null && currentConnection.id<=highestConnectionId){
// We do a direct connection in three cases:
// 1. If the connection is explicitly set to be direct
// 2. If it is automatic and the receiver is not a QObject (no thread() function)
// 3. If it is automatic, the receiver is a QObject and the sender and receiver
// are both in the current thread
Object receiver;
if(currentConnection instanceof SlotObjectConnection){
Object lambdaOwner = ((SlotObjectConnection) currentConnection).lambdaOwner();
if(lambdaOwner!=null)
receiver = lambdaOwner;
else
receiver = currentConnection.resolveReceiver();
}else {
receiver = currentConnection.resolveReceiver();
}
if(!currentConnection.receiverAvailable()){
currentConnection = eraseAndNext(currentConnection);
continue;
}
QThread receiverThread = currentConnection.receiverThread();
Object[] _args = args;
if(currentConnection.argumentCount(){
if(c instanceof AbstractReflectiveConnection){
AbstractReflectiveConnection methodConnection = (AbstractReflectiveConnection)c;
return String.format("Emit signal %1$s: direct invocation of %2$s, receiver=%3$s",
signal.fullName(),
methodConnection.slot,
receiver==null ? "(static)" : AccessUtility.instance.getClass(receiver).getName());
}else {
return String.format("Emit signal %1$s: direct invocation of slot object.", signal.fullName());
}
});
try{
invokeConnection(senderObject, currentConnection, _args);
} catch (RuntimeException | Error e) {
throw e;
} catch (Throwable e) {
if(currentConnection instanceof AbstractReflectiveConnection){
AbstractReflectiveConnection methodConnection = (AbstractReflectiveConnection)currentConnection;
throw new QSignalInvocationException(String.format("Exception caught in signal %1$s after invoking slot %2$s: sender=%3$s, receiver=%4$s",
signal.fullName(),
methodConnection.slot,
senderObject != null ? AccessUtility.instance.getClass(senderObject).getName() : "N/A",
receiver==null ? "(static)" : AccessUtility.instance.getClass(receiver).getName()
),e);
}else{
throw new QSignalInvocationException(String.format("Exception caught in signal %1$s: sender=%2$s, receiver=%3$s",
signal.fullName(),
senderObject != null ? AccessUtility.instance.getClass(senderObject).getName() : "N/A",
receiver==null ? "N/A" : AccessUtility.instance.getClass(receiver).getName()
),e);
}
}
} else {
QtThreadAffineInterface eventReceiver;
if (receiver instanceof QtThreadAffineInterface) {
eventReceiver = (QtThreadAffineInterface) receiver;
}else if (receiver==null && receiverThread!=null) {
eventReceiver = ()->receiverThread;
}else {
eventReceiver = null;
}
if (eventReceiver!=null) {
AbstractConnection c = currentConnection;
logger.finest(()->{
if(c instanceof AbstractReflectiveConnection){
AbstractReflectiveConnection methodConnection = (AbstractReflectiveConnection)c;
return String.format("Emit signal %1$s: queueing invocation of %2$s, receiver=%3$s",
signal.fullName(),
methodConnection.slot,
AccessUtility.instance.getClass(receiver).getName());
}else {
return String.format("Emit signal %1$s: queueing invocation of slot object.", signal.fullName());
}
});
logger.finest(()->"new MetaCall() current thread = "+Thread.currentThread() + "event receiver thread = "+eventReceiver.thread()+" of object "+AccessUtility.instance.getClass(eventReceiver).getName());
logger.finest(()->c.isBlockingQueuedConnection() ? "invokeAndWait" : "invokeLater");
MetaCall metaCall;
if(currentConnection.isBlockingQueuedConnection()) {
if(receiverThreadIsCurrent) {
logger.log(java.util.logging.Level.SEVERE,
()->String.format("Qt: Dead lock detected while activating a BlockingQueuedConnection: signal is %1$s, receiver is %2$s",
signal.fullName(),
AccessUtility.instance.getClass(receiver).getName()
)
);
}
if(currentConnection instanceof AbstractReflectiveConnection){
AbstractReflectiveConnection methodConnection = (AbstractReflectiveConnection)currentConnection;
metaCall = new BlockedMetaCall<>(eventReceiver, this, currentConnection, senderObject, methodConnection.slot, _args);
}else {
metaCall = new BlockedMetaCall<>(eventReceiver, this, currentConnection, senderObject, null, _args);
}
}else {
if(currentConnection instanceof AbstractReflectiveConnection){
AbstractReflectiveConnection methodConnection = (AbstractReflectiveConnection)currentConnection;
metaCall = new MetaCall<>(eventReceiver, this, currentConnection, senderObject, methodConnection.slot, _args);
}else {
metaCall = new MetaCall<>(eventReceiver, this, currentConnection, senderObject, null, _args);
}
}
metaCall.start();
}else{
logger.log(java.util.logging.Level.SEVERE,
()->String.format("Cannot emit signal %1$s: queued connection to not thread-affine receiver %2$s.",
signal.fullName(),
receiver==null ? "N/A" : AccessUtility.instance.getClass(receiver).getName()
)
);
currentConnection = next(currentConnection);
continue;
}
}
currentConnection = next(currentConnection);
}
}
void invokeConnection(Emitter senderObject, AbstractConnection connection, Object[] args) throws Throwable {
connection.invoke(args);
}
private static class MetaCall extends QObject{
final QtThreadAffineInterface eventReceiver;
private final Object arguments[];
private final LeightweightSignalCore core;
private final AbstractConnection connection;
private final Emitter signalEmitter;
private Throwable throwable;
private final Method slot;
public MetaCall(QtThreadAffineInterface eventReceiver, LeightweightSignalCore core, AbstractConnection connection,
Emitter senderObject, Method slot, Object[] arguments) {
super();
this.eventReceiver = eventReceiver;
this.arguments = arguments;
this.core = core;
this.connection = connection;
this.signalEmitter = senderObject;
this.slot = slot;
moveToThread(eventReceiver.thread());
}
final void throwException() {
if(throwable instanceof RuntimeException)
throw (RuntimeException)throwable;
else if(throwable instanceof Error)
throw (Error)throwable;
else if(throwable!=null) {
if(slot!=null){
throw new QSignalInvocationException(String.format("Exception caught in signal %1$s after invoking slot %2$s: sender=%3$s, receiver=%4$s",
core,
slot,
this.signalEmitter != null ? AccessUtility.instance.getClass(this.signalEmitter).getName() : "N/A",
eventReceiver==null ? "(static)" : eventReceiver
),throwable);
}else{
throw new QSignalInvocationException(String.format("Exception caught in signal %1$s: sender=%2$s, receiver=%3$s",
core,
this.signalEmitter != null ? AccessUtility.instance.getClass(this.signalEmitter).getName() : "N/A",
eventReceiver==null ? "N/A" : eventReceiver
),throwable);
}
}
}
final void invoke() {
Object receiver;
boolean isStatic = false;
if(connection instanceof SlotObjectConnection){
Object lambdaOwner = ((SlotObjectConnection) connection).lambdaOwner();
if(lambdaOwner!=null)
receiver = lambdaOwner;
else
receiver = connection.resolveReceiver();
}else if(slot!=null){
isStatic = Modifier.isStatic(slot.getModifiers());
receiver = connection.resolveReceiver();
}else {
return;
}
if ((receiver == null && !isStatic)
|| (receiver instanceof NativeUtility.Object && ((NativeUtility.Object)receiver).isDisposed()) )
return;
try{
logger.finest(()->{
if(slot!=null){
return String.format("Emit signal %1$s: queued invoke %2$s, receiver=%3$s",
core,
slot,
receiver==null ? "(static)" : receiver);
}else {
return String.format("Emit signal %1$s: queued invoke slot object.", core);
}
});
core.invokeConnection(signalEmitter, connection, arguments);
} catch (Throwable e) {
throwable = e;
}
}
@Override
public final boolean event(QEvent event) {
if(event.type()==QEvent.Type.DeferredDispose
&& !(eventReceiver instanceof QtObjectInterface && ((QtObjectInterface)eventReceiver).isDisposed() )) {
try {
invoke();
} catch (Throwable e) {
Logger.getLogger("io.qt.core").log(Level.SEVERE, "Exception thrown during method invocation.", e);
}
finished();
}
return super.event(event);
}
void finished() {
try {
throwException();
} catch (Throwable e) {
Logger.getLogger("io.qt.core").log(Level.SEVERE, "Exception thrown during method invocation.", e);
}
}
void start() {
NativeUtility.setCppOwnership(this);
disposeLater();
}
}
private static class BlockedMetaCall extends MetaCall{
public BlockedMetaCall(QtThreadAffineInterface eventReceiver, LeightweightSignalCore core, AbstractConnection connection, Emitter senderObject, Method slot, Object[] arguments) {
super(eventReceiver, core, connection, senderObject, slot, arguments);
}
@Override
void finished() {
synchronized (this) {
notifyAll();
}
}
@Override
void start() {
synchronized (this) {
disposeLater();
try {
wait();
} catch (InterruptedException e) {
throw new QUnsuccessfulInvocationException(e);
}
}
throwException();
}
}
@Override
final Connection addConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, MethodHandle slotHandle,
LambdaArgsProvider lambdaArgs, ConnectionType[] connectionType) {
if(isUnique(connectionType)){
AbstractConnection currentConnection = begin();
while(currentConnection!=null){
Object resolvedReceiver = currentConnection.resolveReceiver();
if(currentConnection instanceof AbstractReflectiveConnection){
if (resolvedReceiver == receiver
&& slot.equals(((AbstractReflectiveConnection)currentConnection).slot)) {
return new NonConnection();
}
}
currentConnection = next(currentConnection);
}
}
if(slotHandle==null){
try{
slotHandle = ReflectionUtility.privateLookup(slot.getDeclaringClass()).unreflect(slot);
if(slotHandle.isVarargsCollector()) {
slotHandle = slotHandle.asFixedArity();
}
} catch (Throwable e2) {
logger.log(java.util.logging.Level.WARNING, "Exception caught while analyzing slot "+slot, e2);
return new NonConnection();
}
}
AbstractConnection conn;
if(Modifier.isStatic(slot.getModifiers())/* && !(slot.isSynthetic() && receiver!=null)*/) {
if(lambdaArgs==null){
StaticSlotInvoker invoker = ReflectionUtility.getStaticSlotInvoker(slot, slotHandle);
if(invoker==null) {
conn = new StaticReflectiveConnection(slot, connectionType);
}else {
conn = new StaticInvokerConnection(invoker, slot, connectionType);
}
}else {
StaticLambdaArgsSlotInvoker invoker = ReflectionUtility.getStaticSlotInvoker(slot, slotHandle, lambdaArgs.size());
if(invoker==null) {
conn = new StaticLambdaArgsReflectiveConnection(slot, lambdaArgs, connectionType);
}else {
conn = new StaticLambdaArgsInvokerConnection(invoker, slot, lambdaArgs, connectionType);
}
}
}else {
if(lambdaArgs==null){
SlotInvoker invoker = ReflectionUtility.getSlotInvoker(slot, slotHandle);
if(invoker==null) {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QObject) {
if(isDirect(connectionType))
conn = new QObjectDirectReflectiveConnection(new WeakReference<>((QObject)receiver), slot, connectionType);
else
conn = new QObjectReflectiveConnection(new WeakReference<>((QObject)receiver), slot, connectionType);
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new QtInstanceThreadAffineReflectiveConnection(new WeakReference<>((QtObjectInterface)receiver), slot, connectionType);
}else {
conn = new QtInstanceReflectiveConnection(new WeakReference<>((QtObjectInterface)receiver), slot, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new ThreadAffineReflectiveConnection(new WeakReference<>((QtThreadAffineInterface)receiver), slot, connectionType);
}else {
conn = new ReflectiveConnection<>(new WeakReference<>(receiver), slot, connectionType);
}
}else {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QObject) {
if(isDirect(connectionType))
conn = new QObjectDirectInvokerConnection(new WeakReference<>((QObject)receiver), invoker, slot, connectionType);
else
conn = new QObjectInvokerConnection(new WeakReference<>((QObject)receiver), invoker, slot, connectionType);
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new QtInstanceThreadAffineInvokerConnection(new WeakReference<>((QtObjectInterface)receiver), invoker, slot, connectionType);
}else {
conn = new QtInstanceInvokerConnection(new WeakReference<>((QtObjectInterface)receiver), invoker, slot, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new ThreadAffineInvokerConnection(new WeakReference<>((QtThreadAffineInterface)receiver), invoker, slot, connectionType);
}else {
conn = new InvokerConnection<>(new WeakReference<>(receiver), invoker, slot, connectionType);
}
}
}else {
LambdaArgsSlotInvoker invoker = ReflectionUtility.getSlotInvoker(slot, slotHandle, lambdaArgs.size());
if(invoker==null) {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QObject) {
if(isDirect(connectionType))
conn = new QObjectLambdaArgsDirectReflectiveConnection(new WeakReference<>((QObject)receiver), slot, lambdaArgs, connectionType);
else
conn = new QObjectLambdaArgsReflectiveConnection(new WeakReference<>((QObject)receiver), slot, lambdaArgs, connectionType);
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new QtInstanceThreadAffineLambdaArgsReflectiveConnection(new WeakReference<>((QtObjectInterface)receiver), slot, lambdaArgs, connectionType);
}else {
conn = new QtInstanceLambdaArgsReflectiveConnection(new WeakReference<>((QtObjectInterface)receiver), slot, lambdaArgs, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new ThreadAffineLambdaArgsReflectiveConnection(new WeakReference<>((QtThreadAffineInterface)receiver), slot, lambdaArgs, connectionType);
}else {
conn = new LambdaArgsReflectiveConnection<>(new WeakReference<>(receiver), slot, lambdaArgs, connectionType);
}
}else {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QObject) {
if(isDirect(connectionType))
conn = new QObjectLambdaArgsDirectInvokerConnection(new WeakReference<>((QObject)receiver), invoker, slot, lambdaArgs, connectionType);
else
conn = new QObjectLambdaArgsInvokerConnection(new WeakReference<>((QObject)receiver), invoker, slot, lambdaArgs, connectionType);
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new QtInstanceThreadAffineLambdaArgsInvokerConnection(new WeakReference<>((QtObjectInterface)receiver), invoker, slot, lambdaArgs, connectionType);
}else {
conn = new QtInstanceLambdaArgsInvokerConnection(new WeakReference<>((QtObjectInterface)receiver), invoker, slot, lambdaArgs, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new ThreadAffineLambdaArgsInvokerConnection(new WeakReference<>((QtThreadAffineInterface)receiver), invoker, slot, lambdaArgs, connectionType);
}else {
conn = new LambdaArgsInvokerConnection<>(new WeakReference<>(receiver), invoker, slot, lambdaArgs, connectionType);
}
}
}
}
if(!(receiver instanceof QtThreadAffineInterface) && (conn.isQueuedConnection() || conn.isBlockingQueuedConnection())) {
throw new IllegalArgumentException(String.format("Cannot establish %1$s connection to slot of not thread-affine receiver",
conn.isBlockingQueuedConnection() ? "blocking-queued" : "queued"));
}
addConnection(conn);
return new LightweightConnection(signal, conn);
}
@Override
final Connection addConnectionToSlotObject(AbstractSignal signal,
SlotConnectionFactory factory, Object lambdaOwner, Class lambdaOwnerClass, int lambdaHashCode, Slot slotObject, ConnectionType[] connectionType) {
if(isUnique(connectionType)){
AbstractConnection currentConnection = begin();
while(currentConnection!=null){
Object resolvedReceiver = currentConnection.resolveReceiver();
if(currentConnection instanceof SlotObjectConnection){
if (resolvedReceiver == slotObject) {
return new NonConnection();
}
}
currentConnection = next(currentConnection);
}
}
SlotObjectConnection conn = factory.create(new WeakReference(lambdaOwner), lambdaOwnerClass, lambdaHashCode, slotObject, connectionType);
if(!(lambdaOwner instanceof QtThreadAffineInterface) && (conn.isQueuedConnection() || conn.isBlockingQueuedConnection())) {
throw new IllegalArgumentException(String.format("Cannot establish %1$s connection to slot of not thread-affine receiver",
conn.isBlockingQueuedConnection() ? "blocking-queued" : "queued"));
}
addConnection(conn);
return new LightweightConnection(signal, conn);
}
@Override
final boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot, boolean allowNativeDisconnect) {
boolean returned = false;
Method slotMethod = null;
if(slot!=null) {
switch(slot.methodType()) {
case Constructor:
break;
case Signal:
break;
case Method:
case Slot:
slotMethod = slot.toReflectedMethod();
break;
default:
break;
}
}
AbstractConnection currentConnection = begin();
while(currentConnection!=null){
Object resolvedReceiver = currentConnection.resolveReceiver();
if(currentConnection instanceof MetaMethodConnection){
if (resolvedReceiver == null) { // GCed receiver
currentConnection = eraseAndNext(currentConnection);
continue;
} else if ((receiver == null || resolvedReceiver == receiver)
&& (slot == null || slot.equals(((MetaMethodConnection)currentConnection).slot))) {
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}else if(currentConnection instanceof AbstractReflectiveConnection){
if (resolvedReceiver == null) { // GCed receiver
currentConnection = eraseAndNext(currentConnection);
continue;
} else if ((receiver == null || resolvedReceiver == receiver)
&& (slot==null || (slotMethod != null && slotMethod.equals(((AbstractReflectiveConnection)currentConnection).slot)))) {
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}else if(currentConnection instanceof SlotObjectConnection){
SlotObjectConnection slotObjectConnection = (SlotObjectConnection)currentConnection;
Object lambdaOwner = slotObjectConnection.lambdaOwner();
Class lambdaOwnerClass = slotObjectConnection.lambdaOwnerClass;
if(lambdaOwner!=null || lambdaOwnerClass!=null){
if(receiver != null && slot == null){
if(lambdaOwner == receiver ||
lambdaOwnerClass == receiver){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}else if(receiver == null && slot == null){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}else{
// remove if lambda owner has been disposed
if(lambdaOwner instanceof NativeUtility.Object && NativeUtility.nativeId((NativeUtility.Object)lambdaOwner)==0){
currentConnection = eraseAndNext(currentConnection);
continue;
}
}
}else if(resolvedReceiver == receiver){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}
currentConnection = next(currentConnection);
}
return returned;
}
@Override
final boolean removeConnectionToMethod(AbstractSignal signal, Object receiver, Method slot, Object[] lambdaArgs, boolean allowNativeDisconnect) {
boolean returned = false;
AbstractConnection currentConnection = begin();
while(currentConnection!=null) {
Object resolvedReceiver = currentConnection.resolveReceiver();
if(currentConnection instanceof MetaMethodConnection){
if (resolvedReceiver == null) { // GCed receiver
currentConnection = eraseAndNext(currentConnection);
continue;
} else if ((receiver == null || resolvedReceiver == receiver) && slot == null) {
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}else if(currentConnection instanceof AbstractReflectiveConnection){
if (resolvedReceiver == null) { // GCed receiver
currentConnection = eraseAndNext(currentConnection);
continue;
} else if ((receiver == null || resolvedReceiver == receiver)
&& (slot == null || slot.equals(((AbstractReflectiveConnection)currentConnection).slot))) {
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}else if(currentConnection instanceof SlotObjectConnection){
SlotObjectConnection slotObjectConnection = (SlotObjectConnection)currentConnection;
Object lambdaOwner = slotObjectConnection.lambdaOwner();
Class lambdaOwnerClass = slotObjectConnection.lambdaOwnerClass;
if(lambdaOwner!=null || lambdaOwnerClass!=null){
if(receiver != null && slot == null){
if(lambdaOwner == receiver ||
lambdaOwnerClass == receiver){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}else if(receiver == null && slot == null){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}else{
// remove if lambda owner has been disposed
if(lambdaOwner instanceof NativeUtility.Object && NativeUtility.nativeId((NativeUtility.Object)lambdaOwner)==0){
currentConnection = eraseAndNext(currentConnection);
continue;
}
}
}else if(resolvedReceiver == receiver){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}
currentConnection = next(currentConnection);
}
return returned;
}
@Override
final boolean removeConnectionToSlotObject(AbstractSignal signal,
Serializable slotObject, Class _functionalInterfaceClass, Object _lambdaOwner, Class _lambdaOwnerClass,
int _lambdaHashCode, boolean useLambdaInfo) {
boolean returned = true;
if(useLambdaInfo) {
AbstractConnection currentConnection = begin();
while(currentConnection!=null) {
Object resolvedReceiver = currentConnection.resolveReceiver();
if(currentConnection instanceof SlotObjectConnection){
SlotObjectConnection slotObjectConnection = (SlotObjectConnection)currentConnection;
Object lambdaOwner = slotObjectConnection.lambdaOwner();
Class lambdaOwnerClass = slotObjectConnection.lambdaOwnerClass;
if(resolvedReceiver==slotObject || (
_functionalInterfaceClass!=null
&& _functionalInterfaceClass.isInstance(resolvedReceiver)
&& _lambdaOwner==lambdaOwner
&& _lambdaOwnerClass==lambdaOwnerClass
&& _lambdaHashCode==slotObjectConnection.lambdaHashCode
)){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}
currentConnection = next(currentConnection);
}
}else {
AbstractConnection currentConnection = begin();
while(currentConnection!=null) {
Object resolvedReceiver = currentConnection.resolveReceiver();
if(resolvedReceiver==slotObject){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
currentConnection = next(currentConnection);
}
}
return returned;
}
@Override
final boolean removeConnection(AbstractSignal signal, LightweightConnection javaConnection) {
boolean returned = false;
AbstractConnection currentConnection = begin();
while(currentConnection!=null){
Object resolvedReceiver = currentConnection.resolveReceiver();
if(currentConnection instanceof SlotObjectConnection){
SlotObjectConnection slotObjectConnection = (SlotObjectConnection)currentConnection;
Object lambdaOwner = slotObjectConnection.lambdaOwner();
Class lambdaOwnerClass = slotObjectConnection.lambdaOwnerClass;
if(lambdaOwner!=null || lambdaOwnerClass!=null){
if(currentConnection.equals(javaConnection.connection.get())){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}else{
// remove if lambda owner has been disposed
if(lambdaOwner instanceof NativeUtility.Object && NativeUtility.nativeId((NativeUtility.Object)lambdaOwner)==0){
currentConnection = eraseAndNext(currentConnection);
continue;
}
}
}else if(currentConnection.equals(javaConnection.connection.get())){
currentConnection = eraseAndNext(currentConnection);
returned = true;
continue;
}
}else {
if (resolvedReceiver == null // GCed receiver
|| currentConnection.equals(javaConnection.connection.get())) {
currentConnection = eraseAndNext(currentConnection);
continue;
}
}
currentConnection = next(currentConnection);
}
return returned;
}
@Override
final Connection addConnectionToMethod(AbstractSignal signal, Object receiver, QMetaMethod slot,
ConnectionType[] connectionType) {
Method slotMethod = null;
switch(slot.methodType()) {
case Slot:
case Method:
try {
slotMethod = slot.methodType()==QMetaMethod.MethodType.Signal ? null : slot.toReflectedMethod();
} catch (Throwable e) {}
break;
default:
break;
}
AbstractConnection conn;
if(slotMethod!=null) {
if(Modifier.isStatic(slotMethod.getModifiers())) {
StaticSlotInvoker invoker = ReflectionUtility.getStaticSlotInvoker(slotMethod, null);
if(invoker==null) {
conn = new StaticReflectiveConnection(slotMethod, connectionType);
}else {
conn = new StaticInvokerConnection(invoker, slotMethod, connectionType);
}
}else {
SlotInvoker invoker = ReflectionUtility.getSlotInvoker(slotMethod, null);
if(invoker==null) {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new QtInstanceThreadAffineReflectiveConnection(new WeakReference<>((QtObjectInterface)receiver), slotMethod, connectionType);
}else {
conn = new QtInstanceReflectiveConnection(new WeakReference<>((QtObjectInterface)receiver), slotMethod, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new ThreadAffineReflectiveConnection(new WeakReference<>((QtThreadAffineInterface)receiver), slotMethod, connectionType);
}else {
conn = new ReflectiveConnection<>(new WeakReference<>(receiver), slotMethod, connectionType);
}
}else {
if(receiver instanceof QtObjectInterface) {
if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new QtInstanceThreadAffineInvokerConnection(new WeakReference<>((QtObjectInterface)receiver), invoker, slotMethod, connectionType);
}else {
conn = new QtInstanceInvokerConnection(new WeakReference<>((QtObjectInterface)receiver), invoker, slotMethod, connectionType);
}
}else if(receiver instanceof QtThreadAffineInterface && !isDirect(connectionType)){
conn = new ThreadAffineInvokerConnection(new WeakReference<>((QtThreadAffineInterface)receiver), invoker, slotMethod, connectionType);
}else {
conn = new InvokerConnection<>(new WeakReference<>(receiver), invoker, slotMethod, connectionType);
}
}
}
}else if(receiver instanceof QObject){
conn = new QObjectMetaMethodConnection(new WeakReference<>((QObject)receiver), slot, connectionType);
}else if(receiver instanceof QtObjectInterface){
if(receiver instanceof QtThreadAffineInterface){
conn = new QtInstanceThreadAffineMetaMethodConnection(new WeakReference<>((QtObjectInterface)receiver), slot, connectionType);
}else {
conn = new QtInstanceMetaMethodConnection(new WeakReference<>((QtObjectInterface)receiver), slot, connectionType);
}
}else {
conn = new MetaMethodConnection<>(new WeakReference<>(receiver), slot, connectionType);
}
if(!(receiver instanceof QtThreadAffineInterface) && (conn.isQueuedConnection() || conn.isBlockingQueuedConnection())) {
throw new IllegalArgumentException(String.format("Cannot establish %1$s connection to slot of not thread-affine receiver",
conn.isBlockingQueuedConnection() ? "blocking-queued" : "queued"));
}
addConnection(conn);
return new LightweightConnection(signal, conn);
}
@Override
boolean removeConnection(AbstractSignal signal, NativeConnection nativeConnection) {
return false;
}
}
private static class LeightweightSignalBlockerSignalCore extends LeightweightSignalCore {
public LeightweightSignalBlockerSignalCore(Class declaringClass, String name, List signalParameterTypes) {
super(declaringClass, name, signalParameterTypes);
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QtSignalEmitterInterface senderObject = signal.containingObject();
QThread currentThread = QThread.currentThread();
boolean senderWithAffinity = ((QtThreadAffineInterface) senderObject).thread() == currentThread;
if ( senderWithAffinity && ((QtSignalBlockerInterface)senderObject).signalsBlocked()) {
logger.finest(()->String.format("Blocking signal %1$s", signal.fullName()));
return;
}
emitSignal(signal, args, suppliers, senderObject, currentThread);
}
}
private static class LeightweightQtInstanceSignalCore extends LeightweightSignalCore {
public LeightweightQtInstanceSignalCore(Class declaringClass, String name, List signalParameterTypes) {
super(declaringClass, name, signalParameterTypes);
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QtSignalEmitterInterface senderObject = signal.containingObject();
if(((QtObjectInterface) senderObject).isDisposed()) {
disconnectAll();
throw new QNoNativeResourcesException(
"Function call on incomplete object of type: " + AccessUtility.instance.getClass(senderObject).getName());
}else {
super.emitSignal(signal, args, suppliers, senderObject, null);
}
}
}
private static class LeightweightQObjectSignalCore extends LeightweightSignalCore {
public LeightweightQObjectSignalCore(Class declaringClass, String name, List signalParameterTypes) {
super(declaringClass, name, signalParameterTypes);
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QObject senderObject = (QObject)signal.containingObject();
if(senderObject.isDisposed()) {
disconnectAll();
throw new QNoNativeResourcesException(
"Function call on incomplete object of type: " + AccessUtility.instance.getClass(senderObject).getName());
}else {
super.emitSignal(signal, args, suppliers, senderObject, null);
}
}
void invokeConnection(QObject senderObject, AbstractConnection connection, Object[] args) throws Throwable {
connection.invokeOnLock(senderObject, args);
}
}
private static class LeightweightQtInstanceSignalBlockerSignalCore extends LeightweightSignalCore {
public LeightweightQtInstanceSignalBlockerSignalCore(Class declaringClass, String name, List signalParameterTypes) {
super(declaringClass, name, signalParameterTypes);
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QtSignalEmitterInterface senderObject = signal.containingObject();
if(((QtObjectInterface) senderObject).isDisposed()) {
disconnectAll();
throw new QNoNativeResourcesException(
"Function call on incomplete object of type: " + AccessUtility.instance.getClass(senderObject).getName());
}else {
QThread currentThread = QThread.currentThread();
boolean senderWithAffinity = ((QtThreadAffineInterface) senderObject).thread() == currentThread;
if ( senderWithAffinity && ((QtSignalBlockerInterface)senderObject).signalsBlocked()) {
logger.finest(()->String.format("Blocking signal %1$s", signal.fullName()));
return;
}
super.emitSignal(signal, args, suppliers, senderObject, currentThread);
}
}
}
private static class LeightweightCheckingSignalCore extends LeightweightSignalCore {
private final Consumer argumentTest;
public LeightweightCheckingSignalCore(Class declaringClass, String name, List signalParameterTypes, Consumer argumentTest) {
super(declaringClass, name, signalParameterTypes);
this.argumentTest = argumentTest;
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier[] suppliers, QtSignalEmitterInterface senderObject, QThread currentThread) {
argumentTest.accept(args);
if(suppliers.length>0) {
int offset = args.length;
args = Arrays.copyOf(args, args.length+suppliers.length);
for (int i = 0; i < suppliers.length; i++) {
Supplier supplier = suppliers[i];
args[offset+i] = supplier==null ? null : supplier.get();
}
suppliers = AbstractSignal.zeroarray;
}
super.emitSignal(signal, args, suppliers, senderObject, currentThread);
}
}
private static class LeightweightSignalBlockerCheckingSignalCore extends LeightweightCheckingSignalCore {
public LeightweightSignalBlockerCheckingSignalCore(Class declaringClass, String name, List signalParameterTypes, Consumer argumentTest) {
super(declaringClass, name, signalParameterTypes, argumentTest);
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QtSignalEmitterInterface senderObject = signal.containingObject();
QThread currentThread = QThread.currentThread();
boolean senderWithAffinity = ((QtThreadAffineInterface) senderObject).thread() == currentThread;
if ( senderWithAffinity && ((QtSignalBlockerInterface)senderObject).signalsBlocked()) {
logger.finest(()->String.format("Blocking signal %1$s", signal.fullName()));
return;
}
emitSignal(signal, args, suppliers, senderObject, currentThread);
}
}
private static class LeightweightQtInstanceSignalBlockerCheckingSignalCore extends LeightweightCheckingSignalCore {
public LeightweightQtInstanceSignalBlockerCheckingSignalCore(Class declaringClass, String name, List signalParameterTypes, Consumer argumentTest) {
super(declaringClass, name, signalParameterTypes, argumentTest);
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QtSignalEmitterInterface senderObject = signal.containingObject();
if(((QtObjectInterface) senderObject).isDisposed()) {
disconnectAll();
throw new QNoNativeResourcesException(
"Function call on incomplete object of type: " + AccessUtility.instance.getClass(senderObject).getName());
}else {
QThread currentThread = QThread.currentThread();
boolean senderWithAffinity = ((QtThreadAffineInterface) senderObject).thread() == currentThread;
if ( senderWithAffinity && ((QtSignalBlockerInterface)senderObject).signalsBlocked()) {
logger.finest(()->String.format("Blocking signal %1$s", signal.fullName()));
return;
}
super.emitSignal(signal, args, suppliers, senderObject, currentThread);
}
}
}
private static class LeightweightQtInstanceCheckingSignalCore extends LeightweightCheckingSignalCore {
public LeightweightQtInstanceCheckingSignalCore(Class declaringClass, String name, List signalParameterTypes, Consumer argumentTest) {
super(declaringClass, name, signalParameterTypes, argumentTest);
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
QtSignalEmitterInterface senderObject = signal.containingObject();
if(((QtObjectInterface) senderObject).isDisposed()) {
disconnectAll();
throw new QNoNativeResourcesException(
"Function call on incomplete object of type: " + AccessUtility.instance.getClass(senderObject).getName());
}else {
super.emitSignal(signal, args, suppliers, senderObject, null);
}
}
}
private static class LeightweightQObjectCheckingSignalCore extends LeightweightQObjectSignalCore {
private final Consumer argumentTest;
public LeightweightQObjectCheckingSignalCore(Class declaringClass, String name, List signalParameterTypes, Consumer argumentTest) {
super(declaringClass, name, signalParameterTypes);
this.argumentTest = argumentTest;
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier... suppliers) {
argumentTest.accept(args);
if(suppliers.length>0) {
int offset = args.length;
args = Arrays.copyOf(args, args.length+suppliers.length);
for (int i = 0; i < suppliers.length; i++) {
Supplier supplier = suppliers[i];
args[offset+i] = supplier==null ? null : supplier.get();
}
suppliers = AbstractSignal.zeroarray;
}
super.emitSignal(signal, args, suppliers);
}
}
private static class StaticSignalCore extends LeightweightSignalCore {
private StaticSignalCore(String name, List signalParameterTypes, Class declaringClass) {
super(declaringClass, name, signalParameterTypes);
}
@Override
final boolean isStaticSignal(AbstractSignal signal) {
return true;
}
}
private static final class DeclarativeSignalCore extends LeightweightSignalCore {
private DeclarativeSignalCore(String name, List signalParameterTypes) {
super(name, signalParameterTypes);
}
@Override
String fullName(AbstractSignal signal) {
return name();
}
}
private static class StaticCheckingSignalCore extends StaticSignalCore {
private final Consumer argumentTest;
public StaticCheckingSignalCore(String name, List signalParameterTypes, Class declaringClass, Consumer argumentTest) {
super(name, signalParameterTypes, declaringClass);
this.argumentTest = argumentTest;
}
@Override
void emitSignal(AbstractSignal signal, Object[] args, Supplier[] suppliers, QtSignalEmitterInterface senderObject, QThread currentThread) {
argumentTest.accept(args);
if(suppliers.length>0) {
int offset = args.length;
args = Arrays.copyOf(args, args.length+suppliers.length);
for (int i = 0; i < suppliers.length; i++) {
Supplier supplier = suppliers[i];
args[offset+i] = supplier==null ? null : supplier.get();
}
suppliers = AbstractSignal.zeroarray;
}
super.emitSignal(signal, args, suppliers, senderObject, currentThread);
}
}
protected static abstract class AbstractSignal implements QMetaObject.Signal{
private AbstractSignalCore core;
/**
* Instance member signal constructor
* @see QObject
* @see QInstanceMemberSignals
*/
protected AbstractSignal() {
this.core = AnalyzingSignalCore.instance;
}
/**
* Instance member signal constructor
* @see QObject
* @see QInstanceMemberSignals
*/
protected AbstractSignal(Consumer argumentTest) {
this.core = AnalyzingCheckingSignalCore.FACTORY.apply(argumentTest);
}
/**
* Static member signal constructor
* @see QStaticMemberSignals
*/
protected AbstractSignal(Class declaringClass) {
this.core = new AnalyzingStaticSignalCore(declaringClass);
}
/**
* Disposed signal constructor
* @see QtUtilities#getSignalOnDispose(QtObjectInterface)
*/
protected AbstractSignal(Class declaringClass, boolean isDisposed) {
this.core = new StaticSignalCore("disposed", Collections.emptyList(), declaringClass);
}
/**
* Declarable signal constructor
* @see QDeclarableSignals
*/
protected AbstractSignal(String name, Class[] types) {
name = Objects.requireNonNull(name);
switch(types.length){
case 0:
this.core = new DeclarativeSignalCore(name, Collections.emptyList());
break;
case 1:
this.core = new DeclarativeSignalCore(name, Collections.singletonList(new SignalParameterType(types[0], types[0], null, false, false)));
break;
default:
SignalParameterType[] typeList = new SignalParameterType[types.length];
for (int i = 0; i < types.length; i++) {
typeList[i] = new SignalParameterType(types[i], types[i], null, false, false);
}
this.core = new DeclarativeSignalCore(name, Collections.unmodifiableList(Arrays.asList(typeList)));
break;
}
}
@io.qt.QtUninvokable
public final int methodIndex() {
return core.methodIndex(this);
}
/**
* @hidden
*/
@io.qt.QtUninvokable
protected final Class getDeclaringClass() {
return core.getDeclaringClass(this);
}
@io.qt.QtUninvokable
final List signalTypes() {
return core.signalTypes(this);
}
/**
* @hidden
*/
protected boolean isPrivateSignal() {
return true;
}
@io.qt.QtUninvokable
public final List> argumentTypes() {
List types = core.signalTypes(this);
switch(types.size()){
case 0:
return Collections.emptyList();
case 1:
return Collections.singletonList(types.get(0).type);
default:
Class[] result = new Class[types.size()];
for (int i = 0; i < result.length; i++) {
result[i] = types.get(i).type;
}
return Arrays.asList(result);
}
}
@io.qt.QtUninvokable
private boolean isStaticSignal() {
return core.isStaticSignal(this);
}
@io.qt.QtUninvokable
private boolean isQObjectSignal() {
return core.isQObjectSignal(this);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@io.qt.QtUninvokable
public QtSignalEmitterInterface containingObject() {
return null;
}
/**
* Returns the name of the signal
* @return The signal name
*/
@io.qt.QtUninvokable
public final String name() {
return core.name(this);
}
/**
* Returns true if signal is connected
* @return connected
* @see QObject#isSignalConnected(io.qt.core.QMetaMethod)
*/
@io.qt.QtUninvokable
public final boolean isConnected() {
return core.isConnected(this);
}
/**
* Returns the number of receivers connected to this signal
* @return receivers
* @see QObject#receivers(String)
*/
@io.qt.QtUninvokable
public final int receivers() {
return core.receivers(this);
}
/**
* Returns the full name of the signal, on the form "package.class.signalName"
* @return The fully qualified name of the signal
*/
@io.qt.QtUninvokable
public final String fullName() {
return core.fullName(this);
}
final QMetaMethod signalMethod() {
return core.signalMethod(this);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnection(Object receiver, String method, Qt.ConnectionType... connectionType) {
QMetaObject metaObject = receiver instanceof QObject ? ((QObject)receiver).metaObject() : QMetaObject.forType(AccessUtility.instance.getClass(receiver));
Method slotMethod = null;
if(metaObject!=null) {
QMetaMethod metaMethod = metaObject.method(method);
if(metaMethod==null || !metaMethod.isValid()) {
slotMethod = lookupSlot(receiver, method, null);
if (slotMethod == null) {
throw new QNoSuchSlotException(receiver, method);
}
if(methodIndex()>=0)
metaMethod = QMetaMethod.fromReflectedMethod(slotMethod);
}
if(metaMethod!=null && metaMethod.isValid()) {
return addConnectionToMethod(receiver, metaMethod, connectionType);
}
}
if (slotMethod == null)
slotMethod = lookupSlot(receiver, method, null);
if (slotMethod == null) {
throw new QNoSuchSlotException(receiver, method);
}else {
if (slotMethod.isAnnotationPresent(QtUninvokable.class)) {
throw new QUninvokableSlotException(slotMethod);
}
AnnotatedElement[] annotatedParameterTypes = null;
if(ClassAnalyzerUtility.useAnnotatedType)
annotatedParameterTypes = slotMethod.getAnnotatedParameterTypes();
Match match = matchMethodTypes(slotMethod.getParameterTypes(), slotMethod.getGenericParameterTypes(), annotatedParameterTypes);
if(match==Match.NoMatch) {
QMetaMethod signal = signalMethod();
if(signal.isValid()) {
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s -> %2$s", signal.cppMethodSignature(), slotMethod.toGenericString()));
}
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s(%2$s) -> %3$s", name(), signalParameters(), slotMethod.toGenericString()));
}
return addConnectionToMethod(receiver, slotMethod, null, null, connectionType);
}
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnection(Object receiver, Method slotMethod, Qt.ConnectionType... connectionType) {
if (slotMethod.isAnnotationPresent(QtUninvokable.class) && methodIndex()>=0) {
QMetaMethod method = QMetaMethod.fromReflectedMethod(slotMethod);
if(method!=null && method.isValid() && method.methodType()!=QMetaMethod.MethodType.Constructor) {
return addConnectionToMethod(receiver, method, connectionType);
}else {
throw new QUninvokableSlotException(slotMethod);
}
}
AnnotatedElement[] annotatedParameterTypes = null;
if(ClassAnalyzerUtility.useAnnotatedType)
annotatedParameterTypes = slotMethod.getAnnotatedParameterTypes();
if(matchMethodTypes(slotMethod.getParameterTypes(), slotMethod.getGenericParameterTypes(), annotatedParameterTypes)==Match.NoMatch) {
QMetaMethod signal = signalMethod();
if(signal.isValid()) {
QMetaMethod method = QMetaMethod.fromReflectedMethod(slotMethod);
if(method!=null && method.isValid()) {
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s -> %2$s", signal.cppMethodSignature(), method.cppMethodSignature()));
}
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s -> %2$s", signal.cppMethodSignature(), slotMethod.toGenericString()));
}
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s(%2$s) -> %3$s", name(), signalParameters(), slotMethod.toGenericString()));
}
return addConnectionToMethod(receiver, slotMethod, null, null, connectionType);
}
@io.qt.QtUninvokable
private synchronized void resolveSignal() {
if (core instanceof AnalyzingSignalCoreInterface) {
boolean found = false;
if(core instanceof AnalyzingStaticSignalCore) {
AnalyzingStaticSignalCore staticCore = (AnalyzingStaticSignalCore)core;
Field fields[] = staticCore.declaringClass().getDeclaredFields();
for (Field field : fields) {
if (AbstractSignal.class.isAssignableFrom(field.getType())) {
AbstractSignal sig;
try {
sig = (AbstractSignal)ReflectionUtility.readField(null, field);
} catch (Exception e) {
sig = null;
}
if (sig == this) {
if(!java.lang.reflect.Modifier.isStatic(field.getModifiers()))
throw new QSignalDeclarationException(String.format("Missing modifier 'static' at signal %1$s.%2$s.", field.getDeclaringClass().getSimpleName(), field.getName()));
if (!Modifier.isFinal(field.getModifiers())) {
if(!Boolean.getBoolean("qtjambi.allow-nonfinal-signals") && !Boolean.getBoolean("io.qt.allow-nonfinal-signals")) {
java.util.logging.Logger.getLogger("io.qt.internal").severe(String.format("Missing modifier 'final' at signal %1$s.%2$s. Specify JVM argument -Dqtjambi.allow-nonfinal-signals=true to disable this error.", field.getDeclaringClass().getSimpleName(), field.getName()));
throw new QSignalDeclarationException(String.format("Missing modifier 'final' at signal %1$s.%2$s.", field.getDeclaringClass().getSimpleName(), field.getName()));
}
}
found = true;
analyzeSignalField(field);
}
}
}
if (!found)
throw new QSignalInitializationException("Static signals must be declared as static members of a class.");
}else {
QtSignalEmitterInterface containingObject = containingObject();
Class cls = containingObject==null ? null : AccessUtility.instance.getClass(containingObject);
loop: while (cls != null) {
Field fields[] = cls.getDeclaredFields();
for (Field field : fields) {
if (AbstractSignal.class.isAssignableFrom(field.getType())) {
AbstractSignal sig = (AbstractSignal)ReflectionUtility.readField(containingObject, field);
if (sig == this) {
if(java.lang.reflect.Modifier.isStatic(field.getModifiers()))
throw new QSignalDeclarationException(String.format("Modifier 'static' not allowed for signal %1$s.%2$s. Use QStaticMemberSignals instead to declare a static signal.", cls.getSimpleName(), field.getName()));
if (!Modifier.isFinal(field.getModifiers())) {
if(!Boolean.getBoolean("qtjambi.allow-nonfinal-signals") && !Boolean.getBoolean("io.qt.allow-nonfinal-signals")) {
java.util.logging.Logger.getLogger("io.qt.internal").severe(String.format("Missing modifier 'final' at signal %1$s.%2$s. Specify JVM argument -Dqtjambi.allow-nonfinal-signals=true to disable this error.", cls.getSimpleName(), field.getName()));
throw new QSignalDeclarationException(String.format("Missing modifier 'final' at signal %1$s.%2$s.", cls.getSimpleName(), field.getName()));
}
}
found = true;
analyzeSignalField(field);
break loop;
}
}
}
cls = cls.getSuperclass();
}
if (!found) {
if(QObject.class.isAssignableFrom(AccessUtility.instance.getClass(this).getDeclaringClass()))
throw new QSignalDeclarationException("Signals must be declared as members of QObject subclasses.");
else if(QInstanceMemberSignals.class.isAssignableFrom(AccessUtility.instance.getClass(this).getDeclaringClass()))
throw new QSignalDeclarationException("Signals must be declared as members of QInstanceMemberSignals subclasses.");
else
throw new QSignalInitializationException("Unable to resolve signal.");
}
}
if(core instanceof AnalyzingSignalCoreInterface)
throw new QSignalInitializationException("Unable to detect signal name and types");
if (core.signalTypes(this).size() == 0
&& !(this instanceof QObject.Signal0)
&& !(this instanceof QObject.PrivateSignal0)
&& !(this instanceof QStaticMemberSignals.Signal0)
&& !(this instanceof QStaticMemberSignals.PrivateSignal0)
&& !(this instanceof QInstanceMemberSignals.Signal0)
&& !(this instanceof QInstanceMemberSignals.PrivateSignal0)
&& !(this instanceof QDeclarableSignals.AbstractPrivateGenericSignal))
throw new QSignalInitializationException("Signal initialization failed");
}
}
@NativeAccess
@io.qt.QtUninvokable
private synchronized void initializeSignal(Class declaringClass, List signalTypes, final int methodIndex, final long metaObjectId) {
if(methodIndex>=0 && core instanceof AnalyzingSignalCoreInterface) {
if(core instanceof AnalyzingCheckingSignalCore) {
Consumer argumentTest = ((AnalyzingCheckingSignalCore)core).argumentTest;
if(isPrivateSignal()) {
// private signals don't need checks
this.core = new QObjectsPrivateNativeSignalCore(declaringClass, signalTypes, methodIndex, metaObjectId);
}else {
this.core = new QObjectsCheckingNativeSignalCore(signalTypes, methodIndex, metaObjectId, argumentTest);
}
}else if(isPrivateSignal()) {
this.core = new QObjectsPrivateNativeSignalCore(declaringClass, signalTypes, methodIndex, metaObjectId);
}else {
this.core = new QObjectsNativeSignalCore(signalTypes, methodIndex, metaObjectId);
}
}
}
private static final Map> signalTypesByField = Collections.synchronizedMap(new HashMap<>());
@io.qt.QtUninvokable
private synchronized void analyzeSignalField(Field field) {
if(core instanceof AnalyzingSignalCoreInterface) {
boolean isStatic = java.lang.reflect.Modifier.isStatic(field.getModifiers());
Class declaringClass = field.getDeclaringClass();
String name = field.getName();
List signalTypes;
if(QObject.class.isAssignableFrom(declaringClass) && !isStatic) {
QMetaObject metaObject = QMetaObject.forType(declaringClass);
SignalInfo signalInfo = SignalUtility.signalInfo(containingObject(), metaObject, field, null);
if(signalInfo.methodIndex>=0 && signalInfo.enclosingMetaObject!=0) {
boolean isNativeSignal = ClassAnalyzerUtility.isGeneratedClass(declaringClass);
signalTypes = signalInfo.signalTypes;
if(signalTypes==null)
signalTypes = signalTypesByField.computeIfAbsent(field, SignalUtility::resolveSignal);
if(core instanceof AnalyzingCheckingSignalCore) {
Consumer argumentTest = ((AnalyzingCheckingSignalCore)core).argumentTest;
if(isPrivateSignal()) {
if(isNativeSignal)
// private signals don't need checks
this.core = new QObjectsPrivateNativeSignalCore(declaringClass, signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject);
else
this.core = new QObjectsCheckingPrivateSignalCore(declaringClass, signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject, argumentTest);
}else {
if(isNativeSignal)
this.core = new QObjectsCheckingNativeSignalCore(signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject, argumentTest);
else
this.core = new QObjectsCheckingSignalCore(signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject, argumentTest);
}
}else if(isPrivateSignal()) {
if(isNativeSignal)
this.core = new QObjectsPrivateNativeSignalCore(declaringClass, signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject);
else
this.core = new QObjectsPrivateSignalCore(declaringClass, signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject);
}else {
if(isNativeSignal)
this.core = new QObjectsNativeSignalCore(signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject);
else
this.core = new QObjectsSignalCore(signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject);
}
return;
}
}
signalTypes = signalTypesByField.computeIfAbsent(field, SignalUtility::resolveSignal);
if(core instanceof AnalyzingCheckingSignalCore) {
Consumer argumentTest = ((AnalyzingCheckingSignalCore)core).argumentTest;
if(isStatic) {
core = new StaticCheckingSignalCore(name, signalTypes, declaringClass, argumentTest);
}else if(QtObjectInterface.class.isAssignableFrom(declaringClass)) {
if(QObject.class.isAssignableFrom(declaringClass)) {
core = new LeightweightQObjectCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}else if(QtThreadAffineInterface.class.isAssignableFrom(declaringClass)
&& QtSignalBlockerInterface.class.isAssignableFrom(declaringClass)) {
core = new LeightweightQtInstanceSignalBlockerCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}else {
core = new LeightweightQtInstanceCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}
}else if(QtThreadAffineInterface.class.isAssignableFrom(declaringClass)
&& QtSignalBlockerInterface.class.isAssignableFrom(declaringClass)) {
core = new LeightweightSignalBlockerCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}else{
core = new LeightweightCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}
}else {
if(isStatic) {
core = new StaticSignalCore(name, signalTypes, declaringClass);
}else if(QtObjectInterface.class.isAssignableFrom(declaringClass)) {
if(QObject.class.isAssignableFrom(declaringClass)) {
core = new LeightweightQObjectSignalCore(declaringClass, name, signalTypes);
}else if(QtThreadAffineInterface.class.isAssignableFrom(declaringClass)
&& QtSignalBlockerInterface.class.isAssignableFrom(declaringClass)) {
core = new LeightweightQtInstanceSignalBlockerSignalCore(declaringClass, name, signalTypes);
}else {
core = new LeightweightQtInstanceSignalCore(declaringClass, name, signalTypes);
}
}else if(QtThreadAffineInterface.class.isAssignableFrom(declaringClass)
&& QtSignalBlockerInterface.class.isAssignableFrom(declaringClass)) {
core = new LeightweightSignalBlockerSignalCore(declaringClass, name, signalTypes);
}else{
core = new LeightweightSignalCore<>(declaringClass, name, signalTypes);
}
}
}
}
@io.qt.QtUninvokable
synchronized void setCore(Class declaringClass, String name, boolean isStatic, List signalTypes, int methodIndex, long metaObjectId) {
if(core instanceof AnalyzingSignalCoreInterface) {
final boolean isQObjectSignal = QObject.class.isAssignableFrom(declaringClass);
final boolean isNativeSignal = ClassAnalyzerUtility.isGeneratedClass(declaringClass);
if(core instanceof AnalyzingCheckingSignalCore) {
Consumer argumentTest = ((AnalyzingCheckingSignalCore)core).argumentTest;
if(isStatic) {
core = new StaticCheckingSignalCore(name, signalTypes, declaringClass, argumentTest);
}else if(methodIndex>=0 && signalTypes!=null && isQObjectSignal) {
if(isPrivateSignal()) {
if(isNativeSignal)
// private signals don't need checks
core = new QObjectsPrivateNativeSignalCore(declaringClass, signalTypes, methodIndex, metaObjectId);
else
core = new QObjectsCheckingPrivateSignalCore(declaringClass, signalTypes, methodIndex, metaObjectId, argumentTest);
}else {
if(isNativeSignal)
core = new QObjectsCheckingNativeSignalCore(signalTypes, methodIndex, metaObjectId, argumentTest);
else
core = new QObjectsCheckingSignalCore(signalTypes, methodIndex, metaObjectId, argumentTest);
}
}else {
if(QtObjectInterface.class.isAssignableFrom(declaringClass)) {
if(QObject.class.isAssignableFrom(declaringClass)) {
core = new LeightweightQObjectCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}else if(QtThreadAffineInterface.class.isAssignableFrom(declaringClass)
&& QtSignalBlockerInterface.class.isAssignableFrom(declaringClass)) {
core = new LeightweightQtInstanceSignalBlockerCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}else {
core = new LeightweightQtInstanceCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}
}else if(QtThreadAffineInterface.class.isAssignableFrom(declaringClass)
&& QtSignalBlockerInterface.class.isAssignableFrom(declaringClass)) {
core = new LeightweightSignalBlockerCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}else {
core = new LeightweightCheckingSignalCore(declaringClass, name, signalTypes, argumentTest);
}
}
}else {
if(isStatic) {
core = new StaticSignalCore(name, signalTypes, declaringClass);
}else if(methodIndex>=0 && signalTypes!=null && isQObjectSignal) {
if(isPrivateSignal()) {
if(isNativeSignal)
core = new QObjectsPrivateNativeSignalCore(declaringClass, signalTypes, methodIndex, metaObjectId);
else
core = new QObjectsPrivateSignalCore(declaringClass, signalTypes, methodIndex, metaObjectId);
}else {
if(isNativeSignal)
core = new QObjectsNativeSignalCore(signalTypes, methodIndex, metaObjectId);
else
core = new QObjectsSignalCore(signalTypes, methodIndex, metaObjectId);
}
}else {
if(QtObjectInterface.class.isAssignableFrom(declaringClass)) {
if(QObject.class.isAssignableFrom(declaringClass)) {
core = new LeightweightQObjectSignalCore(declaringClass, name, signalTypes);
}else if(QtThreadAffineInterface.class.isAssignableFrom(declaringClass)
&& QtSignalBlockerInterface.class.isAssignableFrom(declaringClass)) {
core = new LeightweightQtInstanceSignalBlockerSignalCore(declaringClass, name, signalTypes);
}else{
core = new LeightweightQtInstanceSignalCore(declaringClass, name, signalTypes);
}
}else if(QtThreadAffineInterface.class.isAssignableFrom(declaringClass)
&& QtSignalBlockerInterface.class.isAssignableFrom(declaringClass)) {
core = new LeightweightSignalBlockerSignalCore(declaringClass, name, signalTypes);
}else{
core = new LeightweightSignalCore<>(declaringClass, name, signalTypes);
}
}
}
}
}
@io.qt.QtUninvokable
private String signalParameters() {
List args = new ArrayList<>();
for (SignalUtility.SignalParameterType type : signalTypes()) {
if(type.genericType!=null && !type.type.isPrimitive())
args.add(type.genericType.getTypeName());
else
args.add(type.type.getName());
}
return String.join(", ", args);
}
/**
* @hidden
*/
@io.qt.QtUninvokable
protected final void emitDefaultSignal(Supplier arg1Default, final Object ... args) {
core.emitSignal(this, args, arg1Default);
}
@io.qt.QtUninvokable
protected final void emitDefaultSignal(Supplier arg1Default, Supplier arg2Default, final Object ... args) {
core.emitSignal(this, args, arg1Default, arg2Default);
}
@io.qt.QtUninvokable
protected final void emitDefaultSignal(Supplier arg1Default, Supplier arg2Default, Supplier arg3Default,
final Object ... args) {
core.emitSignal(this, args, arg1Default, arg2Default, arg3Default);
}
@io.qt.QtUninvokable
protected final void emitDefaultSignal(Supplier arg1Default, Supplier arg2Default, Supplier arg3Default,
Supplier arg4Default, final Object ... args) {
core.emitSignal(this, args, arg1Default, arg2Default, arg3Default,
arg4Default);
}
@io.qt.QtUninvokable
protected final void emitDefaultSignal(Supplier arg1Default, Supplier arg2Default, Supplier arg3Default,
Supplier arg4Default, Supplier arg5Default, final Object ... args) {
core.emitSignal(this, args, arg1Default, arg2Default, arg3Default,
arg4Default, arg5Default);
}
@io.qt.QtUninvokable
protected final void emitDefaultSignal(Supplier arg1Default, Supplier arg2Default, Supplier arg3Default,
Supplier arg4Default, Supplier arg5Default, Supplier arg6Default,
final Object ... args) {
core.emitSignal(this, args, arg1Default, arg2Default, arg3Default,
arg4Default, arg5Default, arg6Default);
}
@io.qt.QtUninvokable
protected final void emitDefaultSignal(Supplier arg1Default, Supplier arg2Default, Supplier arg3Default,
Supplier arg4Default, Supplier arg5Default, Supplier arg6Default,
Supplier arg7Default, final Object ... args) {
core.emitSignal(this, args, arg1Default, arg2Default, arg3Default,
arg4Default, arg5Default, arg6Default,
arg7Default);
}
@io.qt.QtUninvokable
protected final void emitDefaultSignal(Supplier arg1Default, Supplier arg2Default, Supplier arg3Default,
Supplier arg4Default, Supplier arg5Default, Supplier arg6Default,
Supplier arg7Default, Supplier arg8Default, final Object ... args) {
core.emitSignal(this, args, arg1Default, arg2Default, arg3Default,
arg4Default, arg5Default, arg6Default,
arg7Default, arg8Default);
}
@io.qt.QtUninvokable
protected final void emitDefaultSignal(Supplier arg1Default, Supplier arg2Default, Supplier arg3Default,
Supplier arg4Default, Supplier arg5Default, Supplier arg6Default,
Supplier arg7Default, Supplier arg8Default, Supplier arg9Default, final Object ... args) {
core.emitSignal(this, args, arg1Default, arg2Default, arg3Default,
arg4Default, arg5Default, arg6Default,
arg7Default, arg8Default, arg9Default);
}
private final static Supplier[] zeroarray = {};
@io.qt.QtUninvokable
protected final void emitSignal(final Object ... args) {
core.emitSignal(this, args, zeroarray);
}
private enum Match{
NoMatch,
JavaMatch,
NativeMatch
}
@io.qt.QtUninvokable
final boolean matchTypes(Class... types) {
List receivedTypes = Collections.emptyList();
for (int i = 0; i < types.length; i++) {
SignalParameterType signalType = new SignalParameterType(types[i], types[i], null, false, false);
if(i==0) {
if(types.length>1) {
receivedTypes = new ArrayList<>();
receivedTypes.add(signalType);
}else {
receivedTypes = Collections.singletonList(signalType);
}
}else {
receivedTypes.add(signalType);
}
}
List sentTypes = signalTypes();
if(sentTypes.equals(receivedTypes)) {
return true;
}else {
String signalClassName = AccessUtility.instance.getClass(this).getName();
if(signalClassName.endsWith("Default1")
|| signalClassName.endsWith("Default2")
|| signalClassName.endsWith("Default3")
|| signalClassName.endsWith("Default4")
|| signalClassName.endsWith("Default5")
|| signalClassName.endsWith("Default6")
|| signalClassName.endsWith("Default7")
|| signalClassName.endsWith("Default8")
|| signalClassName.endsWith("Default9")) {
sentTypes = new ArrayList<>(sentTypes);
if(signalClassName.endsWith("Default1")) {
if(sentTypes.size()>=1) {
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
}
}else if(signalClassName.endsWith("Default2")) {
if(sentTypes.size()>=2) {
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
}
}else if(signalClassName.endsWith("Default3")) {
if(sentTypes.size()>=3) {
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
}
}else if(signalClassName.endsWith("Default4")) {
if(sentTypes.size()>=4) {
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
}
}else if(signalClassName.endsWith("Default5")) {
if(sentTypes.size()>=5) {
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
}
}else if(signalClassName.endsWith("Default6")) {
if(sentTypes.size()>=6) {
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
}
}else if(signalClassName.endsWith("Default7")) {
if(sentTypes.size()>=7) {
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
}
}else if(signalClassName.endsWith("Default8")) {
if(sentTypes.size()>=8) {
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
}
}else if(signalClassName.endsWith("Default9")) {
if(sentTypes.size()>=9) {
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
sentTypes.remove(sentTypes.size()-1);
if(sentTypes.equals(receivedTypes))
return true;
}
}
}
}
return false;
}
@io.qt.QtUninvokable
private static boolean matches(boolean isNativeConnect, Type sentType, Type receivedType) {
if(sentType instanceof Class) {
Class sentClass = (Class)sentType;
if(receivedType instanceof Class) {
Class receivedClass = (Class)receivedType;
if(sentClass==receivedClass || receivedClass.isAssignableFrom(sentClass)) {
return true;
}
}else if(receivedType instanceof GenericArrayType) {
GenericArrayType genericArrayType = (GenericArrayType)receivedType;
if(sentClass.isArray() && matches(isNativeConnect, sentClass.getComponentType(), genericArrayType.getGenericComponentType())) {
return true;
}
}else if(receivedType instanceof WildcardType) {
WildcardType receivedWildcardType = (WildcardType)receivedType;
for(Type bound : receivedWildcardType.getUpperBounds()) {
if(!matches(isNativeConnect, sentType, bound))
return false;
}
for(Type bound : receivedWildcardType.getLowerBounds()) {
if(!matches(isNativeConnect, bound, sentType))
return false;
}
return true;
}else if(receivedType instanceof TypeVariable) {
TypeVariable receivedVarType = (TypeVariable)receivedType;
for(Type bound : receivedVarType.getBounds()) {
if(!matches(isNativeConnect, sentType, bound))
return false;
}
return true;
}else if(receivedType instanceof ParameterizedType) {
ParameterizedType receivedParamType = (ParameterizedType)receivedType;
return matches(isNativeConnect, sentType, receivedParamType.getRawType());
}
}else if(sentType instanceof WildcardType) {
WildcardType sentWildcardType = (WildcardType)sentType;
for(Type bound : sentWildcardType.getUpperBounds()) {
if(!matches(isNativeConnect, bound, receivedType))
return false;
}
for(Type bound : sentWildcardType.getLowerBounds()) {
if(!matches(isNativeConnect, receivedType, bound))
return false;
}
return true;
}else if(sentType instanceof TypeVariable) {
TypeVariable sentVarType = (TypeVariable)receivedType;
for(Type bound : sentVarType.getBounds()) {
if(!matches(isNativeConnect, bound, receivedType))
return false;
}
return true;
}else if(sentType instanceof ParameterizedType) {
ParameterizedType sentParamType = (ParameterizedType)sentType;
if(receivedType instanceof WildcardType) {
WildcardType receivedWildcardType = (WildcardType)receivedType;
for(Type bound : receivedWildcardType.getUpperBounds()) {
if(!matches(isNativeConnect, sentType, bound))
return false;
}
for(Type bound : receivedWildcardType.getLowerBounds()) {
if(!matches(isNativeConnect, bound, sentType))
return false;
}
return true;
}else if(receivedType instanceof TypeVariable) {
TypeVariable receivedVarType = (TypeVariable)receivedType;
for(Type bound : receivedVarType.getBounds()) {
if(!matches(isNativeConnect, sentType, bound))
return false;
}
return true;
}else if(receivedType instanceof ParameterizedType) {
ParameterizedType receivedParamType = (ParameterizedType)receivedType;
if(!matches(isNativeConnect, sentParamType.getRawType(), receivedParamType.getRawType()))
return false;
Type[] sentArgs = sentParamType.getActualTypeArguments();
Type[] receivedArgs = receivedParamType.getActualTypeArguments();
if(sentArgs.length!=receivedArgs.length)
return false;
for (int i = 0; i < receivedArgs.length; i++) {
if(!matches(isNativeConnect, sentArgs[i], receivedArgs[i]))
return false;
}
return true;
}else if(receivedType instanceof Class) {
return matches(isNativeConnect, sentParamType.getRawType(), receivedType);
}
}else if(sentType instanceof GenericArrayType) {
GenericArrayType sentArrayType = (GenericArrayType)sentType;
if(receivedType instanceof GenericArrayType) {
GenericArrayType receivedArrayType = (GenericArrayType)receivedType;
if(matches(isNativeConnect, sentArrayType.getGenericComponentType(), receivedArrayType.getGenericComponentType()))
return true;
}else if(receivedType instanceof Class && ((Class) receivedType).isArray()) {
return matches(isNativeConnect, sentArrayType.getGenericComponentType(), ((Class) receivedType).getComponentType());
}
}
return false;
}
@io.qt.QtUninvokable
private static Match matches(boolean isNativeConnect, SignalParameterType sentType, SignalParameterType receivedType) {
Class sentClass = sentType.type;
Class receivedClass = receivedType.type;
if(sentClass==null)
sentClass = Object.class;
if(sentClass==int.class)
sentClass = Integer.class;
if(sentClass==byte.class)
sentClass = Byte.class;
if(sentClass==short.class)
sentClass = Short.class;
if(sentClass==long.class)
sentClass = Long.class;
if(sentClass==boolean.class)
sentClass = Boolean.class;
if(sentClass==char.class)
sentClass = Character.class;
if(sentClass==double.class)
sentClass = Double.class;
if(sentClass==float.class)
sentClass = Float.class;
if(receivedClass==null)
receivedClass = Object.class;
if(receivedClass==int.class)
receivedClass = Integer.class;
if(receivedClass==byte.class)
receivedClass = Byte.class;
if(receivedClass==short.class)
receivedClass = Short.class;
if(receivedClass==long.class)
receivedClass = Long.class;
if(receivedClass==boolean.class)
receivedClass = Boolean.class;
if(receivedClass==char.class)
receivedClass = Character.class;
if(receivedClass==double.class)
receivedClass = Double.class;
if(receivedClass==float.class)
receivedClass = Float.class;
if(isNativeConnect) {
if(Set.class==receivedClass)
receivedClass = QSet.class;
if(List.class==receivedClass)
receivedClass = QList.class;
if(NavigableMap.class==receivedClass)
receivedClass = QMap.class;
if(Map.class==receivedClass)
receivedClass = QHash.class;
if(Set.class==sentClass)
sentClass = QSet.class;
if(List.class==sentClass)
sentClass = QList.class;
if(NavigableMap.class==sentClass)
sentClass = QMap.class;
if(Map.class==sentClass)
sentClass = QHash.class;
}
if(sentClass==receivedClass || receivedClass.isAssignableFrom(sentClass)) {
if(sentType.genericType==null
|| sentType.genericType instanceof Class
|| sentType.genericType==receivedType.genericType) {
return (!isNativeConnect || sentClass==receivedClass) && (sentType.isReference==receivedType.isReference) && (sentType.isPointer==receivedType.isPointer) ? Match.NativeMatch : Match.JavaMatch;
}else if(sentType.genericType instanceof GenericArrayType || receivedType.genericType instanceof GenericArrayType) {
if(matches(isNativeConnect, sentType.genericType, receivedType.genericType)) {
return (!isNativeConnect || sentClass==receivedClass) && (sentType.isReference==receivedType.isReference) && (sentType.isPointer==receivedType.isPointer) ? Match.NativeMatch : Match.JavaMatch;
}
}else if(sentType.genericType instanceof ParameterizedType) {
ParameterizedType sentParamType = (ParameterizedType)sentType.genericType;
if(receivedType.genericType instanceof ParameterizedType) {
ParameterizedType receivedParamType = (ParameterizedType)receivedType.genericType;
Type[] sentArgs = sentParamType.getActualTypeArguments();
Type[] receivedArgs = receivedParamType.getActualTypeArguments();
if(sentArgs.length!=receivedArgs.length)
return Match.NoMatch;
for (int i = 0; i < receivedArgs.length; i++) {
if(!matches(isNativeConnect, sentArgs[i], receivedArgs[i]))
return Match.NoMatch;
}
return (sentType.isReference==receivedType.isReference) && (sentType.isPointer==receivedType.isPointer) ? Match.NativeMatch : Match.JavaMatch;
}else if(receivedType.genericType instanceof Class){
if(sentParamType.getRawType()==receivedType.genericType || ((Class)receivedType.genericType).isAssignableFrom((Class)sentParamType.getRawType())) {
return Match.JavaMatch;
}
}else if(receivedType.genericType instanceof TypeVariable) {
return Match.JavaMatch;
}
}else if(sentType.genericType instanceof TypeVariable) {
return Match.JavaMatch;
}
}else if(sentType.genericType instanceof TypeVariable) {
return Match.JavaMatch;
}
if(isNativeConnect) {
if(receivedClass==QStringList.class
&& sentClass==QList.class
&& sentType.genericType instanceof ParameterizedType) {
Type[] sentArgs = ((ParameterizedType)sentType.genericType).getActualTypeArguments();
if(sentArgs.length==1 && sentArgs[0]==String.class) {
return (sentType.isReference==receivedType.isReference) && (sentType.isPointer==receivedType.isPointer) ? Match.NativeMatch : Match.JavaMatch;
}
}
}
return Match.NoMatch;
}
@io.qt.QtUninvokable
private static Match matches(boolean isNativeConnect, List sentTypes, List receivedTypes) {
Match result = Match.NoMatch;
if(sentTypes.size()==receivedTypes.size()) {
result = Match.NativeMatch;
for (int i = 0; i < sentTypes.size(); i++) {
switch(matches(isNativeConnect, sentTypes.get(i), receivedTypes.get(i))) {
case JavaMatch:
result = Match.JavaMatch;
break;
case NativeMatch:
break;
case NoMatch:
return Match.NoMatch;
default:
break;
}
}
return result;
}
return result;
}
@io.qt.QtUninvokable
private Match matchMethodTypes(List receivedTypes, String signalClassName) {
List sentTypes = signalTypes();
boolean isNativeConnect = isQObjectSignal() && methodIndex()>=0;
Match result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch) {
return result;
}else if(sentTypes.size()>receivedTypes.size()){
sentTypes = new ArrayList<>(sentTypes);
while(sentTypes.size()>receivedTypes.size()) {
sentTypes.remove(sentTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}else if(sentTypes.size()(receivedTypes);
if(signalClassName.endsWith("Default1")) {
if(receivedTypes.size()>=1) {
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}else if(signalClassName.endsWith("Default2")) {
if(receivedTypes.size()>=2) {
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}else if(signalClassName.endsWith("Default3")) {
if(receivedTypes.size()>=3) {
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}else if(signalClassName.endsWith("Default4")) {
if(receivedTypes.size()>=4) {
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}else if(signalClassName.endsWith("Default5")) {
if(receivedTypes.size()>=5) {
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}else if(signalClassName.endsWith("Default6")) {
if(receivedTypes.size()>=6) {
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}else if(signalClassName.endsWith("Default7")) {
if(receivedTypes.size()>=7) {
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}else if(signalClassName.endsWith("Default8")) {
if(receivedTypes.size()>=8) {
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}else if(signalClassName.endsWith("Default9")) {
if(receivedTypes.size()>=9) {
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
receivedTypes.remove(receivedTypes.size()-1);
result = matches(isNativeConnect, sentTypes, receivedTypes);
if(result!=Match.NoMatch)
return result;
}
}
}
return result;
}
@io.qt.QtUninvokable
private Match matchMethodTypes(Class[] types, Type[] genericTypes, AnnotatedElement[] annotatedTypes) {
List typeList = Collections.emptyList();
for (int i = 0; i < types.length; i++) {
Class type = types[i];
Type genericType = genericTypes==null ? type : genericTypes[i];
AnnotatedElement annotatedType = annotatedTypes==null ? null : annotatedTypes[i];
SignalParameterType signalType = new SignalParameterType(type, genericType, annotatedType, false, false);
if(i==0) {
if(types.length>1) {
typeList = new ArrayList<>();
typeList.add(signalType);
}else {
typeList = Collections.singletonList(signalType);
}
}else {
typeList.add(signalType);
}
}
return matchMethodTypes(typeList, null);
}
protected void checkConnection(Object receiver, boolean slotObject) {
if(receiver==this) {
throw new IllegalArgumentException("Cannot connect a signal to itself.");
}
}
@io.qt.QtUninvokable
private QMetaObject.Connection addConnectionToMethod(Object receiver, Method slot, MethodHandle slotHandle, Object[] lambdaArgs, Qt.ConnectionType... connectionType) {
checkConnection(receiver, false);
LambdaArgsProvider _lambdaArgs;
if(lambdaArgs!=null && lambdaArgs.length>0) {
boolean hasWeakLambdaArgs = false;
if(this.containingObject()!=null) {
for (int i = 0; i < lambdaArgs.length; i++) {
if(lambdaArgs[i] == this.containingObject()) {
hasWeakLambdaArgs = true;
break;
}
}
}
boolean isThreadAffine = receiver==null && lambdaArgs[0] instanceof QtThreadAffineInterface;
if(hasWeakLambdaArgs) {
Supplier[] array = new Supplier[lambdaArgs.length];
for (int i = 0; i < lambdaArgs.length; i++) {
Object arg = lambdaArgs[i];
if(arg!=null && arg == this.containingObject()) {
WeakReference reference = new WeakReference<>(arg);
array[i] = ()->{
Object result = reference.get();
if(result==null)
throw new LambdaArgumentGoneException();
return result;
};
}else {
array[i] = ()->arg;
}
}
if(isThreadAffine) {
_lambdaArgs = new ThreadAffineSupplierLambdaArgsProvider(new WeakReference<>((QtThreadAffineInterface)lambdaArgs[0]), array);
}else {
_lambdaArgs = new SupplierLambdaArgsProvider(array);
}
}else {
if(isThreadAffine) {
_lambdaArgs = new ThreadAffineLambdaArgsProvider(new WeakReference<>((QtThreadAffineInterface)lambdaArgs[0]), lambdaArgs);
}else {
_lambdaArgs = new ObjectLambdaArgsProvider(lambdaArgs);
}
}
}else {
_lambdaArgs = null;
}
return core.addConnectionToMethod(this, receiver, slot, slotHandle, _lambdaArgs, connectionType);
}
@io.qt.QtUninvokable
private QMetaObject.Connection addConnectionToMethod(Object receiver, QMetaMethod slot, Qt.ConnectionType... connectionType) {
checkConnection(receiver, false);
QMetaMethod signalMethod = signalMethod();
boolean checkConnectArgs = false;
if(signalMethod.isValid()
&& (checkConnectArgs = QMetaObject.checkConnectArgs(signalMethod, slot))) {
boolean hasWrappers = false;
if(isDynamic(signalMethod.enclosingMetaObject())) {
for(QByteArray ba : signalMethod.parameterTypes()) {
if(ba.startsWith((byte)'J') && ba.endsWith(wrapper)) {
hasWrappers = true;
break;
}
}
if(!hasWrappers) {
for(QByteArray ba : slot.parameterTypes()) {
if(ba.startsWith((byte)'J') && ba.endsWith(wrapper)) {
hasWrappers = true;
break;
}
}
}
}
if(!hasWrappers) {
return core.addConnectionToMethod(this, receiver, slot, connectionType);
}
}
if(receiver instanceof QObject && slot.methodType()==QMetaMethod.MethodType.Signal) {
AbstractSignal signal = slot.toSignal((QObject)receiver);
if(signal!=null) {
Match match = matchMethodTypes(signal.signalTypes(), AccessUtility.instance.getClass(signal).getName());
switch(match) {
case NoMatch:
if(signalMethod!=null && signalMethod.isValid()) {
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s -> %2$s", signalMethod.cppMethodSignature(), slot.cppMethodSignature()));
}
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s(%2$s) -> %3$s", name(), signalParameters(), slot.cppMethodSignature()));
case NativeMatch:
if(!checkConnectArgs)
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s(%2$s) -> %3$s", name(), signalParameters(), slot.cppMethodSignature()));
case JavaMatch:
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s(%2$s) -> %3$s", name(), signalParameters(), slot.cppMethodSignature()));
default:
break;
}
}
}else if(slot.methodType()==QMetaMethod.MethodType.Method
|| slot.methodType()==QMetaMethod.MethodType.Slot){
Method slotMethod = slot.toReflectedMethod();
if(slotMethod!=null) {
AnnotatedElement[] annotatedParameterTypes = null;
if(ClassAnalyzerUtility.useAnnotatedType)
annotatedParameterTypes = slotMethod.getAnnotatedParameterTypes();
Match match = matchMethodTypes(slotMethod.getParameterTypes(), slotMethod.getGenericParameterTypes(), annotatedParameterTypes);
switch(match) {
case NoMatch:
if(signalMethod!=null && signalMethod.isValid()) {
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s -> %2$s", signalMethod.cppMethodSignature(), slot.cppMethodSignature()));
}
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s(%2$s) -> %3$s", name(), signalParameters(), slot.cppMethodSignature()));
case NativeMatch:
if(checkConnectArgs)
break;
case JavaMatch:
return addConnectionToMethod(receiver, slotMethod, null, null, connectionType);
default:
break;
}
}
}
return core.addConnectionToMethod(this, receiver, slot, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(GenericSlot slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(GenericSlotObjectConnection::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot0 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection0::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot1 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection1::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot2 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection2::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot3 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection3::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot4 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection4::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot5 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection5::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot6 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection6::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot7 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection7::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot8 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection8::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection addConnectionToSlotObject(Slot9 slotObject, Qt.ConnectionType[] connectionType) {
return addConnectionToSlotObject(SlotObjectConnection9::new, slotObject, connectionType);
}
@io.qt.QtUninvokable
private QMetaObject.Connection addConnectionToSlotObject(SlotConnectionFactory factory, Slot slotObject, Qt.ConnectionType[] connectionType) {
Object lambdaOwner = null;
Class lambdaOwnerClass = null;
int lambdaHashCode = 0;
Class lambdaClass = AccessUtility.instance.getClass(slotObject);
SerializedLambda serializedLambda = ClassAnalyzerUtility.serializeLambdaExpression(slotObject);
if(serializedLambda!=null){
MethodHandle methodHandle = ClassAnalyzerUtility.LambdaTools.lambdaSlotHandles(lambdaClass, serializedLambda);
Method reflectiveMethod = null;
if(methodHandle!=null){
try{
reflectiveMethod = MethodHandles.reflectAs(Method.class, methodHandle);
if(methodHandle.isVarargsCollector()) {
methodHandle = methodHandle.asFixedArity();
}
} catch (Throwable e1) {
logger.log(java.util.logging.Level.WARNING, "Exception caught while analyzing slot", e1);
}
}
if(reflectiveMethod!=null && methodHandle!=null){
Object arg1;
if(Modifier.isStatic(reflectiveMethod.getModifiers())) {
Object[] lambdaArgs = null;
Object owner = null;
if(isStaticAsInstance(reflectiveMethod, serializedLambda)){
owner = ClassAnalyzerUtility.LambdaTools.getCapturedArg(serializedLambda, 0);
checkConnection(owner, true);
lambdaArgs = new Object[ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)-1];
for(int i=0; i0){
lambdaArgs = new Object[ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)];
for(int i=0; i[] paraTypes = reflectiveMethod.getParameterTypes();
Type[] genTypes = reflectiveMethod.getGenericParameterTypes();
AnnotatedElement[] annTypes = null;
if(ClassAnalyzerUtility.useAnnotatedType)
annTypes = reflectiveMethod.getAnnotatedParameterTypes();
if(ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)>0) {
Class[] _paraTypes = new Class[paraTypes.length-ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)];
Type[] _genTypes = new Type[genTypes.length-ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)];
System.arraycopy(paraTypes, ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda), _paraTypes, 0, _paraTypes.length);
System.arraycopy(genTypes, ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda), _genTypes, 0, _genTypes.length);
paraTypes = _paraTypes;
genTypes = _genTypes;
if(annTypes!=null) {
AnnotatedElement[] _annTypes = new AnnotatedElement[annTypes.length-ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)];
System.arraycopy(annTypes, ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda), _annTypes, 0, _annTypes.length);
annTypes = _annTypes;
}
}
Match match = matchMethodTypes(paraTypes, genTypes, annTypes);
if(match==Match.NoMatch) {
QMetaMethod signal = this.signalMethod();
if(signal.isValid()) {
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s -> %2$s", signal.cppMethodSignature(), reflectiveMethod.toGenericString()));
}
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s(%2$s) -> %3$s", name(), signalParameters(), reflectiveMethod.toGenericString()));
}
return addConnectionToMethod(owner, reflectiveMethod, methodHandle, lambdaArgs, connectionType);
}else if(ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)>0
&& (arg1 = ClassAnalyzerUtility.LambdaTools.getCapturedArg(serializedLambda, 0))!=null
&& reflectiveMethod.getDeclaringClass().isInstance(arg1)){
if (reflectiveMethod.isAnnotationPresent(QtUninvokable.class)) {
QMetaMethod method = QMetaMethod.fromReflectedMethod(reflectiveMethod);
if(method.isValid()) {
reflectiveMethod = method.toReflectedMethod();
}
}
Object[] lambdaArgs = null;
if(ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)>1){
lambdaArgs = new Object[ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)-1];
for(int i=1; i[] paraTypes = reflectiveMethod.getParameterTypes();
Type[] genTypes = reflectiveMethod.getGenericParameterTypes();
AnnotatedElement[] annTypes = null;
if(ClassAnalyzerUtility.useAnnotatedType)
annTypes = reflectiveMethod.getAnnotatedParameterTypes();
if(lambdaArgs==null || lambdaArgs.length==0) {
QMetaMethod metaMethod = methodIndex()>=0 ? QMetaMethod.fromReflectedMethod(reflectiveMethod) : null;
if(metaMethod!=null && metaMethod.isValid()) {
if(metaMethod.methodType()==QMetaMethod.MethodType.Signal) {
Method _reflectiveMethod = reflectiveMethod;
java.util.logging.Logger.getLogger("io.qt.internal").warning(()->String.format("Java method '%1$s' points to signal '%2$s'. Use signal connection instead: connect(receiver.%3$s)", _reflectiveMethod.toGenericString(), metaMethod.methodSignature(), metaMethod.name()));
}
return addConnectionToMethod(arg1, metaMethod, connectionType);
}
}else {
Class[] _paraTypes = new Class[paraTypes.length-lambdaArgs.length];
Type[] _genTypes = new Type[genTypes.length-lambdaArgs.length];
System.arraycopy(paraTypes, lambdaArgs.length, _paraTypes, 0, _paraTypes.length);
System.arraycopy(genTypes, lambdaArgs.length, _genTypes, 0, _genTypes.length);
paraTypes = _paraTypes;
genTypes = _genTypes;
if(annTypes!=null) {
AnnotatedElement[] _annTypes = new AnnotatedElement[annTypes.length-lambdaArgs.length];
System.arraycopy(annTypes, lambdaArgs.length, _annTypes, 0, _annTypes.length);
annTypes = _annTypes;
}
}
Match match = matchMethodTypes(paraTypes, genTypes, annTypes);
if(match==Match.NoMatch) {
QMetaMethod signal = this.signalMethod();
if(signal.isValid()) {
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s -> %2$s", signal.cppMethodSignature(), reflectiveMethod.toGenericString()));
}
throw new QMisfittingSignatureException(String.format("Incompatible sender/receiver arguments %1$s(%2$s) -> %3$s", name(), signalParameters(), reflectiveMethod.toGenericString()));
}
return addConnectionToMethod(arg1, reflectiveMethod, methodHandle, lambdaArgs, connectionType);
}else{
try {
lambdaOwnerClass = Class.forName(ClassAnalyzerUtility.LambdaTools.getCapturingClass(serializedLambda).replace('/', '.'));
} catch (Throwable e) {
}
}
}else{
String[] split = lambdaClass.getName().split("Lambda\\$");
if(split.length>0){
while(split[0].endsWith("$") || split[0].endsWith(".")){
split[0] = split[0].substring(0, split[0].length()-1);
}
try {
lambdaOwnerClass = Class.forName(split[0]);
} catch (Throwable e) {
}
}
try {
lambdaOwner = ReflectionUtility.readField(slotObject, lambdaClass, "arg$1", null);
} catch (Throwable e) {
}
checkConnection(lambdaOwner, true);
}
lambdaHashCode = ClassAnalyzerUtility.LambdaTools.hashcode(serializedLambda);
if(ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(serializedLambda)>0){
lambdaOwner = ClassAnalyzerUtility.LambdaTools.getCapturedArg(serializedLambda, 0);
if(!(lambdaOwner instanceof QtThreadAffineInterface) && !(lambdaOwner instanceof SignalUtility.AbstractSignal)){
for(int i=1; i=0; --signalTypeCount) {
for(Method mtd : AccessUtility.instance.getClass(signalObject).getMethods()) {
if(mtd.getName().equals("emit")
&& mtd.getReturnType()==void.class
&& mtd.getParameterCount()==signalTypeCount) {
return addConnectionToMethod(signalObject, mtd, null, null, connectionType);
}
}
}
if(mfe!=null)
throw mfe;
return new NonConnection();//this.core.addConnectionToSignal(this, signalObject, connectionType);
}
@io.qt.QtUninvokable
protected final boolean removeConnectionToSignalObject(AbstractSignal signalObject) {
this.name();
QMetaMethod method = signalObject.signalMethod();
if(method.isValid()) {
boolean result = removeConnectionToMethod(signalObject.containingObject(), method, true);
if(result)
return result;
}
for(int signalTypeCount = signalTypes().size(); signalTypeCount>=0; --signalTypeCount) {
for(Method mtd : AccessUtility.instance.getClass(signalObject).getMethods()) {
if(mtd.getName().equals("emit")
&& mtd.getReturnType()==void.class
&& mtd.getParameterCount()==signalTypeCount) {
return removeConnectionToMethod(signalObject, mtd, null, true);
}
}
}
return false;
}
@io.qt.QtUninvokable
protected final boolean removeConnectionToSlotObject(Serializable slotObject) {
if(slotObject instanceof AbstractSignal) {
return removeConnectionToSignalObject((AbstractSignal)slotObject);
}
SerializedLambda _serializedLambda = ClassAnalyzerUtility.serializeLambdaExpression(slotObject);
Class _lambdaOwnerClass = null;
Class _functionalInterfaceClass = null;
if(_serializedLambda!=null){
try {
_lambdaOwnerClass = AccessUtility.instance.getClass(slotObject).getClassLoader().loadClass(ClassAnalyzerUtility.LambdaTools.getCapturingClass(_serializedLambda).replace('/', '.'));
_functionalInterfaceClass = AccessUtility.instance.getClass(slotObject).getClassLoader().loadClass(ClassAnalyzerUtility.LambdaTools.getFunctionalInterfaceClass(_serializedLambda).replace('/', '.'));
} catch (Throwable e) {
}
MethodHandle methodHandle = ClassAnalyzerUtility.LambdaTools.lambdaSlotHandles(AccessUtility.instance.getClass(slotObject), _serializedLambda);
Method reflectiveMethod = null;
if(methodHandle!=null){
reflectiveMethod = MethodHandles.reflectAs(Method.class, methodHandle);
if(methodHandle.isVarargsCollector()) {
methodHandle = methodHandle.asFixedArity();
}
}
Object _lambdaOwner = null;
if(reflectiveMethod!=null && _serializedLambda!=null && methodHandle!=null){
if(Modifier.isStatic(reflectiveMethod.getModifiers())){
Object[] lambdaArgs = null;
if(ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(_serializedLambda)>0){
lambdaArgs = new Object[ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(_serializedLambda)];
for(int i=0; i0
&& reflectiveMethod.getDeclaringClass().isInstance(ClassAnalyzerUtility.LambdaTools.getCapturedArg(_serializedLambda, 0))){
Object[] lambdaArgs = null;
if(ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(_serializedLambda)>1){
if(ClassAnalyzerUtility.LambdaTools.getCapturedArg(_serializedLambda, 0) instanceof AbstractSignal && reflectiveMethod.getName().equals("emit")) {
AbstractSignal signalObject = (AbstractSignal)ClassAnalyzerUtility.LambdaTools.getCapturedArg(_serializedLambda, 0);
QMetaMethod method = signalObject.signalMethod();
if(method.isValid()) {
boolean result = removeConnectionToMethod(signalObject.containingObject(), method, true);
if(result)
return result;
}
}
lambdaArgs = new Object[ClassAnalyzerUtility.LambdaTools.getCapturedArgCount(_serializedLambda)-1];
for(int i=1; i0){
_lambdaOwner = ClassAnalyzerUtility.LambdaTools.getCapturedArg(_serializedLambda, 0);
if(!(_lambdaOwner instanceof QtThreadAffineInterface) || !(_lambdaOwner instanceof SignalUtility.AbstractSignal)){
for(int i=1; i{
protected SignalConfiguration(Signal signal, Class[] types) {
super();
this.signal = signal;
this.types = types;
}
final Signal signal;
final Class[] types;
}
private static abstract class AbstractMultiSignalCore{
public AbstractMultiSignalCore() {
super();
}
abstract List signals(AbstractMultiSignal multiSignal);
abstract String name(AbstractMultiSignal multiSignal);
abstract Class declaringClass(AbstractMultiSignal multiSignal);
}
private static class AnalyzingMultiSignalCore extends AbstractMultiSignalCore{
@SuppressWarnings("rawtypes")
public final static AnalyzingMultiSignalCore INSTANCE = new AnalyzingMultiSignalCore<>();
public AnalyzingMultiSignalCore() {
super();
}
List preparedSignals(){ return null; }
final List signals(AbstractMultiSignal multiSignal) {
multiSignal.resolveMultiSignal();
return multiSignal.core.signals(multiSignal);
}
final String name(AbstractMultiSignal multiSignal) {
multiSignal.resolveMultiSignal();
return multiSignal.core.name(multiSignal);
}
final Class declaringClass(AbstractMultiSignal multiSignal){
multiSignal.resolveMultiSignal();
return multiSignal.core.declaringClass(multiSignal);
}
}
private final static class PreparedAnalyzingMultiSignalCore extends AnalyzingMultiSignalCore{
final List signals;
public PreparedAnalyzingMultiSignalCore(List signals) {
super();
this.signals = signals;
}
List preparedSignals(){ return signals; }
}
private static final class MultiSignalCore extends AbstractMultiSignalCore{
public MultiSignalCore(List signals, String name, Class declaringClass) {
super();
this.signals = signals;
this.name = name;
this.declaringClass = declaringClass;
}
private final List signals;
private String name;
private Class declaringClass;
@Override
final List signals(AbstractMultiSignal multiSignal) {return signals;}
@Override
final String name(AbstractMultiSignal multiSignal) {return name;}
@Override
final Class declaringClass(AbstractMultiSignal multiSignal){return declaringClass;}
}
protected static abstract class AbstractMultiSignal {
private AbstractMultiSignalCore core;
@SuppressWarnings("unchecked")
protected AbstractMultiSignal(){
super();
this.core = AnalyzingMultiSignalCore.INSTANCE;
}
@SafeVarargs
protected AbstractMultiSignal(SignalConfiguration signal1, SignalConfiguration signal2, SignalConfiguration... furtherSignals){
super();
List signals = new ArrayList<>(furtherSignals.length+2);
for (int i = 0; i < furtherSignals.length+2; i++) {
SignalConfiguration signalConfiguration;
if(i==0) {
signalConfiguration = signal1;
}else if(i==1) {
signalConfiguration = signal2;
}else {
signalConfiguration = furtherSignals[i-2];
}
AbstractSignal signal = signalConfiguration.signal;
if(signal.core instanceof AnalyzingSignalCore && signalConfiguration.types!=null) {
signal.core = new MultiSignalAnalyingSignalCore(this, signalConfiguration.types);
}
signals.add(signalConfiguration.signal);
}
this.core = new PreparedAnalyzingMultiSignalCore<>(signals);
}
@io.qt.QtUninvokable
@SuppressWarnings("unchecked")
private synchronized final void resolveMultiSignal() {
if(core instanceof AnalyzingMultiSignalCore) {
AnalyzingMultiSignalCore core = (AnalyzingMultiSignalCore)this.core;
boolean found = false;
QtSignalEmitterInterface containingObject = containingObject();
Class cls = containingObject==null ? AccessUtility.instance.getClass(this).getDeclaringClass() : AccessUtility.instance.getClass(containingObject);
loop: while (cls != null) {
Field fields[] = cls.getDeclaredFields();
for (Field field : fields) {
if (AbstractMultiSignal.class.isAssignableFrom(field.getType())) {
AbstractMultiSignal sig;
try {
sig = (AbstractMultiSignal)ReflectionUtility.readField(containingObject, field);
} catch (Exception e1) {
sig = null;
}
if (sig == this) {
found = true;
if(QObject.MultiSignal.class.isAssignableFrom(field.getType()))
initializeMultiSignal(this, field.getDeclaringClass(), field);
if(this.core instanceof AnalyzingMultiSignalCore) {
if(QStaticMemberSignals.MultiSignal.class.isAssignableFrom(field.getType())) {
if(!java.lang.reflect.Modifier.isStatic(field.getModifiers()))
throw new QSignalDeclarationException(String.format("Missing modifier 'static' at signal %1$s.%2$s.", cls.getSimpleName(), field.getName()));
}else {
if(java.lang.reflect.Modifier.isStatic(field.getModifiers()))
throw new QSignalDeclarationException(String.format("Modifier 'static' not allowed for signal %1$s.%2$s. Use QStaticMemberSignals instead to declare a static signal.", cls.getSimpleName(), field.getName()));
}
if (!Modifier.isFinal(field.getModifiers()))
throw new QSignalDeclarationException(String.format("Missing modifier 'final' at signal %1$s.%2$s.", cls.getSimpleName(), field.getName()));
if(!Modifier.isFinal(field.getType().getModifiers()))
throw new QSignalDeclarationException(String.format("Missing modifier 'final' at signal class %1$s.", field.getType().getTypeName()));
if(field.getDeclaringClass()!=field.getType().getEnclosingClass())
throw new QSignalDeclarationException(String.format("Declaration error at signal %1$s.%2$s: Multi signal class has to be declared in the class using it.", cls.getSimpleName(), field.getName()));
String name = field.getName();
final Class declaringClass = field.getDeclaringClass();
boolean isStatic = java.lang.reflect.Modifier.isStatic(field.getModifiers());
QMetaObject metaObject = QMetaObject.forType(declaringClass);
List signals = core.preparedSignals();
if(signals==null) {
Class multiSignalSuperType = field.getType().getSuperclass();
while(multiSignalSuperType!=null
&& multiSignalSuperType.getEnclosingClass()!=QObject.class
&& multiSignalSuperType.getEnclosingClass()!=QStaticMemberSignals.class
&& multiSignalSuperType.getEnclosingClass()!=QInstanceMemberSignals.class) {
multiSignalSuperType = multiSignalSuperType.getSuperclass();
}
SignalClasses signalClasses = signalClasses(multiSignalSuperType.getEnclosingClass());
if(signalClasses==null)
throw new QSignalInitializationException("Unable to resolve multi signal "+name+".");
Map>,EmitMethodInfo> emitMethods = SignalUtility.findEmitMethods(AccessUtility.instance.getClass(this));
if(emitMethods==null)
throw new QSignalInitializationException("Unable to resolve multi signal "+name+".");
signals = new ArrayList<>();
for(Map.Entry>,EmitMethodInfo> entry : emitMethods.entrySet()) {
Class signalClass;
if(Modifier.isPublic(entry.getValue().method.getModifiers())) {
signalClass = signalClasses.getPublicSignal(entry.getKey().size());
}else {
signalClass = signalClasses.getPrivateSignal(entry.getKey().size());
}
if(signalClass==null)
throw new QSignalInitializationException("Unable to resolve multi signal "+name+".");
Function factory = getSignalFactory(signalClass);
if(factory==null)
throw new QSignalInitializationException("Unable to resolve multi signal "+name+".");
Signal signal;
try {
signal = factory.apply(containingObject==null ? declaringClass : containingObject);
} catch (Throwable e) {
throw new QSignalInitializationException("Unable to resolve multi signal "+name+".");
}
signals.add(signal);
SignalInfo signalInfo = SignalUtility.signalInfo(null, metaObject, field, entry.getValue().method);
if(signalInfo.signalTypes==null) {
signal.setCore(declaringClass, name, isStatic, resolveSignal(entry.getValue().method), -1, 0);
}else {
signal.setCore(declaringClass, name, isStatic, signalInfo.signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject);
}
}
signals = Collections.unmodifiableList(signals);
}else {
for (AbstractSignal signal : signals) {
MultiSignalAnalyingSignalCore signalCore = (MultiSignalAnalyingSignalCore)signal.core;
Class _cls = AccessUtility.instance.getClass(this);
while (_cls != SignalUtility.AbstractMultiSignal.class) {
try {
Method emitMethod = _cls.getDeclaredMethod("emit", signalCore.types);
SignalInfo signalInfo = SignalUtility.signalInfo(null, metaObject, field, emitMethod);
if(signalInfo.signalTypes==null) {
signal.setCore(declaringClass, name, isStatic, resolveSignal(emitMethod), -1, 0);
}else {
signal.setCore(declaringClass, name, isStatic, signalInfo.signalTypes, signalInfo.methodIndex, signalInfo.enclosingMetaObject);
}
break;
}catch(Throwable t) {}
_cls = _cls.getSuperclass();
}
}
}
this.core = new MultiSignalCore<>(signals, name, declaringClass);
}
break loop;
}
}
}
cls = cls.getSuperclass();
}
if (!found) {
throw new QSignalDeclarationException("Multi signals must be declared as members of QObject subclasses.");
}
}
if(core instanceof AnalyzingMultiSignalCore) {
throw new QSignalInitializationException("Unable to resolve multi signal.");
}
}
@io.qt.QtUninvokable
protected final List signals() {
return core.signals(this);
}
@NativeAccess
@io.qt.QtUninvokable
private final Signal signal(int i) {
List signals = signals();
return i>=0 && i[] signalParameterTypes, Class[] signalObjectTypes) {
if(core instanceof AnalyzingMultiSignalCore) {
List signals = ((AnalyzingMultiSignalCore)core).preparedSignals();
String name = field.getName();
Class declaringClass = field.getDeclaringClass();
boolean isStatic = java.lang.reflect.Modifier.isStatic(field.getModifiers());
List _signals = signals;
if(_signals==null)
_signals = new ArrayList<>();
for (int i = 0; i < signalParameterTypes.length; i++) {
AbstractSignal signal;
if(signals==null) {
Function factory = getSignalFactory(signalObjectTypes[i]);
if(factory==null)
throw new QSignalInitializationException("Unable to initialize multi signal.");
try {
signal = factory.apply(containingObject());
} catch (Throwable e) {
throw new QSignalInitializationException("Unable to initialize multi signal.");
}
_signals.add((Signal)signal);
}else {
signal = signals.get(i);
}
List signalTypes = signalParameterTypes[i];
signal.setCore(declaringClass, name, isStatic, signalTypes, methodIndexes[i], metaObjectIds[i]);
}
core = new MultiSignalCore<>(_signals, name, declaringClass);
}
}
@SuppressWarnings("unchecked")
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal9 overload(Class type1, Class type2, Class type3, Class type4, Class type5,
Class type6, Class type7, Class type8, Class type9) throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal9 && _signal.matchTypes(type1, type2, type3, type4, type5, type6, type7, type8, type9)) {
return (QMetaObject.AbstractPrivateSignal9)signal;
}
}
throwMismatchException(type1, type2, type3, type4, type5, type6, type7, type8, type9);
return null;
}
@SuppressWarnings("unchecked")
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal8 overload(Class type1, Class type2, Class type3, Class type4, Class type5,
Class type6, Class type7, Class type8) throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal8 && _signal.matchTypes(type1, type2, type3, type4, type5, type6, type7, type8)) {
return (QMetaObject.AbstractPrivateSignal8)signal;
}
}
throwMismatchException(type1, type2, type3, type4, type5, type6, type7, type8);
return null;
}
@SuppressWarnings("unchecked")
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal7 overload(Class type1, Class type2, Class type3, Class type4, Class type5,
Class type6, Class type7) throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal7 && _signal.matchTypes(type1, type2, type3, type4, type5, type6, type7)) {
return (QMetaObject.AbstractPrivateSignal7)signal;
}
}
throwMismatchException(type1, type2, type3, type4, type5, type6, type7);
return null;
}
@SuppressWarnings("unchecked")
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal6 overload(Class type1, Class type2, Class type3, Class type4, Class type5,
Class type6) throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal6 && _signal.matchTypes(type1, type2, type3, type4, type5, type6)) {
return (QMetaObject.AbstractPrivateSignal6)signal;
}
}
throwMismatchException(type1, type2, type3, type4, type5, type6);
return null;
}
@SuppressWarnings("unchecked")
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal5 overload(Class type1, Class type2, Class type3, Class type4, Class type5) throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal5 && _signal.matchTypes(type1, type2, type3, type4, type5)) {
return (QMetaObject.AbstractPrivateSignal5)signal;
}
}
throwMismatchException(type1, type2, type3, type4, type5);
return null;
}
@SuppressWarnings("unchecked")
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal4 overload(Class type1, Class type2, Class type3, Class type4) throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal4 && _signal.matchTypes(type1, type2, type3, type4)) {
return (QMetaObject.AbstractPrivateSignal4)signal;
}
}
throwMismatchException(type1, type2, type3, type4);
return null;
}
@SuppressWarnings("unchecked")
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal3 overload(Class type1, Class type2, Class type3) throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal3 && _signal.matchTypes(type1, type2, type3)) {
return (QMetaObject.AbstractPrivateSignal3)signal;
}
}
throwMismatchException(type1, type2, type3);
return null;
}
@SuppressWarnings("unchecked")
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal2 overload(Class type1, Class type2) throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal2 && _signal.matchTypes(type1, type2)) {
return (QMetaObject.AbstractPrivateSignal2)signal;
}
}
throwMismatchException(type1, type2);
return null;
}
@SuppressWarnings("unchecked")
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal1 overload(Class type1) throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal1 && _signal.matchTypes(type1)) {
return (QMetaObject.AbstractPrivateSignal1 )signal;
}
}
throwMismatchException(type1);
return null;
}
@io.qt.QtUninvokable
protected QMetaObject.AbstractPrivateSignal0 overload() throws QNoSuchSignalException{
for(Signal signal : signals()) {
AbstractSignal _signal = signal;
if(_signal instanceof QMetaObject.AbstractPrivateSignal0 && _signal.matchTypes()) {
return (QMetaObject.AbstractPrivateSignal0)signal;
}
}
throwMismatchException();
return null;
}
@io.qt.QtUninvokable
protected boolean disconnect(QMetaObject.Connection connection) {
boolean result = false;
for(AbstractSignal signal : signals()) {
result |= signal.removeConnection(connection);
}
return result;
}
@io.qt.QtUninvokable
protected boolean disconnectAll() {
boolean result = false;
for(Signal signal : signals()) {
result |= signal.removeConnection(null, null);
}
return result;
}
@io.qt.QtUninvokable
protected final boolean disconnect(QMetaObject.AbstractSlot slotObject) {
boolean result = false;
for(AbstractSignal signal : signals()) {
result |= signal.removeConnectionToSlotObject(slotObject);
}
return result;
}
@io.qt.QtUninvokable
protected final boolean disconnect(AbstractSignal signalObject) {
boolean result = false;
for(AbstractSignal signal : signals()) {
result |= signal.removeConnectionToSignalObject(signalObject);
}
return result;
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection connect(AbstractSignal signalObject, Qt.ConnectionType... connectionType) {
List matchingSignals = new ArrayList<>();
for(AbstractSignal _signal : signals()) {
if(_signal.matchMethodTypes(signalObject.signalTypes(), AccessUtility.instance.getClass(signalObject).getName())!=AbstractSignal.Match.NoMatch) {
matchingSignals.add(_signal);
}
}
if(matchingSignals.size()>1) {
List _matchingSignals = new ArrayList<>();
for (AbstractSignal signal : matchingSignals) {
if(signal.signalTypes().size()==signalObject.signalTypes().size()) {
_matchingSignals.add(signal);
}
}
if(!_matchingSignals.isEmpty())
matchingSignals = _matchingSignals;
}
if(matchingSignals.isEmpty()) {
throwMismatchException(signalObject.argumentTypes().toArray(new Class[signalObject.signalTypes().size()]));
}
return matchingSignals.get(0).addConnectionToSignalObject(signalObject, connectionType);
}
@io.qt.QtUninvokable
protected final QMetaObject.Connection connect(QMetaObject.AbstractSlot slotObject, Qt.ConnectionType... connectionType) {
List matchingSignals = new ArrayList<>();
ClassAnalyzerUtility.LambdaInfo info = ClassAnalyzerUtility.lambdaInfo(slotObject);
if(info!=null && info.reflectiveMethod!=null) {
if(info.owner instanceof AbstractSignal && info.reflectiveMethod.getName().equals("emit")) {
return connect((AbstractSignal)info.owner, connectionType);
}
Class[] parameterClassTypes = info.reflectiveMethod.getParameterTypes();
Type[] genericParameterTypes = info.reflectiveMethod.getGenericParameterTypes();
AnnotatedElement[] annotatedParameterTypes = null;
if(ClassAnalyzerUtility.useAnnotatedType)
annotatedParameterTypes = info.reflectiveMethod.getAnnotatedParameterTypes();
if((info.lambdaArgs!=null && !info.lambdaArgs.isEmpty())
|| ((info.owner!=null || info.qobject!=null) && info.reflectiveMethod!=null && Modifier.isStatic(info.reflectiveMethod.getModifiers()))) {
int sub = info.lambdaArgs!=null ? info.lambdaArgs.size() : 0;
if((info.owner!=null || info.qobject!=null) && info.reflectiveMethod!=null && Modifier.isStatic(info.reflectiveMethod.getModifiers())) {
++sub;
}
Class[] _parameterClassTypes = new Class[parameterClassTypes.length - sub];
Type[] _genericParameterTypes = new Type[genericParameterTypes.length - sub];
System.arraycopy(parameterClassTypes, sub, _parameterClassTypes, 0, _parameterClassTypes.length);
System.arraycopy(genericParameterTypes, sub, _genericParameterTypes, 0, _genericParameterTypes.length);
parameterClassTypes = _parameterClassTypes;
genericParameterTypes = _genericParameterTypes;
if(annotatedParameterTypes!=null) {
AnnotatedElement[] _annotatedParameterTypes = new AnnotatedElement[annotatedParameterTypes.length - sub];
System.arraycopy(annotatedParameterTypes, sub, _annotatedParameterTypes, 0, _annotatedParameterTypes.length);
annotatedParameterTypes = _annotatedParameterTypes;
}
}
for(AbstractSignal signal : signals()) {
if(signal.matchMethodTypes(parameterClassTypes, genericParameterTypes, annotatedParameterTypes)!=AbstractSignal.Match.NoMatch) {
matchingSignals.add(signal);
}
}
if(matchingSignals.size()>1) {
List _matchingSignals = new ArrayList<>();
for (AbstractSignal signal : matchingSignals) {
if(signal.signalTypes().size()==parameterClassTypes.length) {
_matchingSignals.add(signal);
}
}
if(!_matchingSignals.isEmpty())
matchingSignals = _matchingSignals;
}
if(matchingSignals.isEmpty()) {
throwMismatchException(parameterClassTypes);
}
}else {
Class[] parameterTypes;
if(slotObject instanceof QMetaObject.Slot0) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot0.class, (QMetaObject.Slot0)slotObject);
}else if(slotObject instanceof QMetaObject.Slot1) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot1.class, (QMetaObject.Slot1)slotObject);
}else if(slotObject instanceof QMetaObject.Slot2) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot2.class, (QMetaObject.Slot2)slotObject);
}else if(slotObject instanceof QMetaObject.Slot3) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot3.class, (QMetaObject.Slot3)slotObject);
}else if(slotObject instanceof QMetaObject.Slot4) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot4.class, (QMetaObject.Slot4)slotObject);
}else if(slotObject instanceof QMetaObject.Slot5) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot5.class, (QMetaObject.Slot5)slotObject);
}else if(slotObject instanceof QMetaObject.Slot6) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot6.class, (QMetaObject.Slot6)slotObject);
}else if(slotObject instanceof QMetaObject.Slot7) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot7.class, (QMetaObject.Slot7)slotObject);
}else if(slotObject instanceof QMetaObject.Slot8) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot8.class, (QMetaObject.Slot8)slotObject);
}else if(slotObject instanceof QMetaObject.Slot9) {
parameterTypes = ClassAnalyzerUtility.lambdaClassTypes(QMetaObject.Slot9.class, (QMetaObject.Slot9)slotObject);
}else{
throw new QMisfittingSignatureException("Invalid slot type "+AccessUtility.instance.getClass(slotObject));
}
if(parameterTypes!=null) {
Class[] parameterClassTypes = new Class[parameterTypes.length-1];
System.arraycopy(parameterTypes, 1, parameterClassTypes, 0, parameterClassTypes.length);
Type[] genericParameterTypes = parameterClassTypes;
AnnotatedElement[] annotatedParameterTypes = null;
for(AbstractSignal signal : signals()) {
if(signal.matchMethodTypes(parameterClassTypes, genericParameterTypes, annotatedParameterTypes)!=AbstractSignal.Match.NoMatch) {
matchingSignals.add(signal);
}
}
if(matchingSignals.size()>1) {
List _matchingSignals = new ArrayList<>();
for (AbstractSignal signal : matchingSignals) {
if(signal.signalTypes().size()==parameterClassTypes.length) {
_matchingSignals.add(signal);
}
}
if(!_matchingSignals.isEmpty())
matchingSignals = _matchingSignals;
}
if(matchingSignals.isEmpty()) {
throwMismatchException(parameterClassTypes);
}
}
}
if(matchingSignals.isEmpty()) {
throwMismatchException();
return null;
}
if(slotObject instanceof QMetaObject.Slot0) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot0)slotObject, connectionType);
}else if(slotObject instanceof QMetaObject.Slot1) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot1)slotObject, connectionType);
}else if(slotObject instanceof QMetaObject.Slot2) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot2)slotObject, connectionType);
}else if(slotObject instanceof QMetaObject.Slot3) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot3)slotObject, connectionType);
}else if(slotObject instanceof QMetaObject.Slot4) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot4)slotObject, connectionType);
}else if(slotObject instanceof QMetaObject.Slot5) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot5)slotObject, connectionType);
}else if(slotObject instanceof QMetaObject.Slot6) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot6)slotObject, connectionType);
}else if(slotObject instanceof QMetaObject.Slot7) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot7)slotObject, connectionType);
}else if(slotObject instanceof QMetaObject.Slot8) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot8)slotObject, connectionType);
}else if(slotObject instanceof QMetaObject.Slot9) {
return matchingSignals.get(0).addConnectionToSlotObject((QMetaObject.Slot9)slotObject, connectionType);
}else if(slotObject!=null){
throw new QMisfittingSignatureException("Invalid slot type "+AccessUtility.instance.getClass(slotObject));
}else {
return null;
}
}
@io.qt.QtUninvokable
protected QMetaObject.Connection connect(Object receiver, String method, Qt.ConnectionType... connectionType) {
QMetaObject metaObject = receiver instanceof QObject ? ((QObject)receiver).metaObject() : QMetaObject.forType(AccessUtility.instance.getClass(receiver));
Class[] parameterClassTypes = null;
List matchingSignals = new ArrayList<>();
Map 