io.qt.core.QInstanceMemberSignals Maven / Gradle / Ivy
/****************************************************************************
**
** Copyright (C) 2009-2021 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.core;
import java.lang.ref.WeakReference;
import java.util.Objects;
import java.util.function.Supplier;
import io.qt.QNoDefaultValueException;
import io.qt.QtSignalEmitterInterface;
import io.qt.QtUninvokable;
import io.qt.core.QMetaObject.AbstractPrivateSignal0;
import io.qt.core.QMetaObject.AbstractPrivateSignal1;
import io.qt.core.QMetaObject.AbstractPrivateSignal2;
import io.qt.core.QMetaObject.AbstractPrivateSignal3;
import io.qt.core.QMetaObject.AbstractPrivateSignal4;
import io.qt.core.QMetaObject.AbstractPrivateSignal5;
import io.qt.core.QMetaObject.AbstractPrivateSignal6;
import io.qt.core.QMetaObject.AbstractPrivateSignal7;
import io.qt.core.QMetaObject.AbstractPrivateSignal8;
import io.qt.core.QMetaObject.AbstractPrivateSignal9;
import io.qt.core.QMetaObject.AbstractPublicSignal0;
import io.qt.core.QMetaObject.AbstractPublicSignal1;
import io.qt.core.QMetaObject.AbstractPublicSignal2;
import io.qt.core.QMetaObject.AbstractPublicSignal3;
import io.qt.core.QMetaObject.AbstractPublicSignal4;
import io.qt.core.QMetaObject.AbstractPublicSignal5;
import io.qt.core.QMetaObject.AbstractPublicSignal6;
import io.qt.core.QMetaObject.AbstractPublicSignal7;
import io.qt.core.QMetaObject.AbstractPublicSignal8;
import io.qt.core.QMetaObject.AbstractPublicSignal9;
import io.qt.core.QMetaObject.AbstractSignal2Default1;
import io.qt.core.QMetaObject.AbstractSignal3Default1;
import io.qt.core.QMetaObject.AbstractSignal3Default2;
import io.qt.core.QMetaObject.AbstractSignal4Default1;
import io.qt.core.QMetaObject.AbstractSignal4Default2;
import io.qt.core.QMetaObject.AbstractSignal4Default3;
import io.qt.core.QMetaObject.AbstractSignal5Default1;
import io.qt.core.QMetaObject.AbstractSignal5Default2;
import io.qt.core.QMetaObject.AbstractSignal5Default3;
import io.qt.core.QMetaObject.AbstractSignal5Default4;
import io.qt.core.QMetaObject.AbstractSignal6Default1;
import io.qt.core.QMetaObject.AbstractSignal6Default2;
import io.qt.core.QMetaObject.AbstractSignal6Default3;
import io.qt.core.QMetaObject.AbstractSignal6Default4;
import io.qt.core.QMetaObject.AbstractSignal6Default5;
import io.qt.core.QMetaObject.AbstractSignal7Default1;
import io.qt.core.QMetaObject.AbstractSignal7Default2;
import io.qt.core.QMetaObject.AbstractSignal7Default3;
import io.qt.core.QMetaObject.AbstractSignal7Default4;
import io.qt.core.QMetaObject.AbstractSignal7Default5;
import io.qt.core.QMetaObject.AbstractSignal7Default6;
import io.qt.core.QMetaObject.AbstractSignal8Default1;
import io.qt.core.QMetaObject.AbstractSignal8Default2;
import io.qt.core.QMetaObject.AbstractSignal8Default3;
import io.qt.core.QMetaObject.AbstractSignal8Default4;
import io.qt.core.QMetaObject.AbstractSignal8Default5;
import io.qt.core.QMetaObject.AbstractSignal8Default6;
import io.qt.core.QMetaObject.AbstractSignal8Default7;
import io.qt.core.QMetaObject.AbstractSignal9Default1;
import io.qt.core.QMetaObject.AbstractSignal9Default2;
import io.qt.core.QMetaObject.AbstractSignal9Default3;
import io.qt.core.QMetaObject.AbstractSignal9Default4;
import io.qt.core.QMetaObject.AbstractSignal9Default5;
import io.qt.core.QMetaObject.AbstractSignal9Default6;
import io.qt.core.QMetaObject.AbstractSignal9Default7;
import io.qt.core.QMetaObject.AbstractSignal9Default8;
/**
* Interface giving access to non-QObject lightweight signals.
* Subtypes also need to implement {@link QtSignalEmitterInterface} to use signals.
*/
public interface QInstanceMemberSignals {
/**
* Use this signal class to define a non-QObject signal.
*/
public static final class Signal0 extends AbstractPublicSignal0 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal0(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
*/
public static final class Signal1 extends AbstractPublicSignal1 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal1(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal2 extends AbstractPublicSignal2 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal2(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal3 extends AbstractPublicSignal3 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal3(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal4 extends AbstractPublicSignal4 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal4(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal5 extends AbstractPublicSignal5 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal5(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal6 extends AbstractPublicSignal6 {
public Signal6(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal7 extends AbstractPublicSignal7 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal7(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal8 extends AbstractPublicSignal8 {
public Signal8(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal9 extends AbstractPublicSignal9 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal9(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*/
public static final class PrivateSignal0 extends AbstractPrivateSignal0 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal0(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit() {
emitSignal();
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal1 extends AbstractPrivateSignal1 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal1(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1) {
emitSignal(arg1);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal2 extends AbstractPrivateSignal2 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal2(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2) {
emitSignal(arg1, arg2);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal3 extends AbstractPrivateSignal3 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal3(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3) {
emitSignal(arg1, arg2, arg3);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal4 extends AbstractPrivateSignal4 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal4(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4) {
emitSignal(arg1, arg2, arg3, arg4);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal5 extends AbstractPrivateSignal5 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal5(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5) {
emitSignal(arg1, arg2, arg3, arg4, arg5);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal6 extends AbstractPrivateSignal6 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal6(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5, F arg6) {
emitSignal(arg1, arg2, arg3, arg4, arg5, arg6);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal7 extends AbstractPrivateSignal7 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal7(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7) {
emitSignal(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal8 extends AbstractPrivateSignal8 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal8(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7, H arg8) {
emitSignal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal9 extends AbstractPrivateSignal9 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal9(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7, H arg8, I arg9) {
emitSignal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal1Default1 extends AbstractPublicSignal1 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal1Default1(Q containingObject, Supplier arg1Default){
super();
if(arg1Default!=null){
this.arg1Default = arg1Default;
}else{
throw new QNoDefaultValueException(1);
}
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
private final Supplier arg1Default;
public void emit() {
emit(arg1Default.get());
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal2Default1 extends AbstractSignal2Default1{
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal2Default1(Q containingObject, Supplier arg2Default) {
super(arg2Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal2Default2 extends AbstractSignal2Default1 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal2Default2(Q containingObject, Supplier arg1Default, Supplier arg2Default){
super(arg2Default);
if(arg1Default!=null){
this.arg1Default = arg1Default;
}else{
throw new QNoDefaultValueException(1);
}
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
private final Supplier arg1Default;
public void emit() {
emit(arg1Default.get());
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal3Default1 extends AbstractSignal3Default1 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal3Default1(Q containingObject, Supplier arg3Default) {
super(arg3Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal3Default2 extends AbstractSignal3Default2 {
public Signal3Default2(Q containingObject, Supplier arg2Default, Supplier arg3Default){
super(arg2Default, arg3Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal3Default3 extends AbstractSignal3Default2 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal3Default3(Q containingObject, Supplier arg1Default, Supplier arg2Default, Supplier arg3Default){
super(arg2Default, arg3Default);
if(arg2Default!=null){
this.arg1Default = arg1Default;
}else{
throw new QNoDefaultValueException(1);
}
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
private final Supplier arg1Default;
public void emit() {
emit(arg1Default.get());
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal4Default1 extends AbstractSignal4Default1{
public Signal4Default1(Q containingObject, Supplier arg4Default){
super(arg4Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal4Default2 extends AbstractSignal4Default2{
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal4Default2(Q containingObject, Supplier arg3Default, Supplier arg4Default){
super(arg3Default, arg4Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal4Default3 extends AbstractSignal4Default3{
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal4Default3(Q containingObject, Supplier arg2Default, Supplier arg3Default, Supplier arg4Default){
super(arg2Default, arg3Default, arg4Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal4Default4 extends AbstractSignal4Default3 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal4Default4(
Q containingObject,
Supplier arg1Default, Supplier arg2Default,
Supplier arg3Default, Supplier arg4Default){
super(arg2Default, arg3Default, arg4Default);
if(arg1Default!=null){
this.arg1Default = arg1Default;
}else{
throw new QNoDefaultValueException(1);
}
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
private final Supplier arg1Default;
public void emit() {
emit(arg1Default.get());
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference