io.qt.serialport.QSerialPort Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of qtjambi-serialport Show documentation
Provides access to hardware and virtual serial ports.
There is a newer version: 6.8.0
package io.qt.serialport;

import io.qt.*;


/**
 * Provides functions to access serial ports
 * Java wrapper for Qt class QSerialPort
 */
public class QSerialPort extends io.qt.core.QIODevice
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * This variable stores the meta-object for the class.
     */
    public static final io.qt.core.@NonNull QMetaObject staticMetaObject = io.qt.core.QMetaObject.forType(QSerialPort.class);
    
    /**
     * Java wrapper for Qt enum QSerialPort::BaudRate
     */
    public enum BaudRate implements QtEnumerator {
        /**
         * Representing QSerialPort::Baud1200
         */
        Baud1200(1200),
        /**
         * Representing QSerialPort::Baud2400
         */
        Baud2400(2400),
        /**
         * Representing QSerialPort::Baud4800
         */
        Baud4800(4800),
        /**
         * Representing QSerialPort::Baud9600
         */
        Baud9600(9600),
        /**
         * Representing QSerialPort::Baud19200
         */
        Baud19200(19200),
        /**
         * Representing QSerialPort::Baud38400
         */
        Baud38400(38400),
        /**
         * Representing QSerialPort::Baud57600
         */
        Baud57600(57600),
        /**
         * Representing QSerialPort::Baud115200
         */
        Baud115200(115200);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private BaudRate(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull BaudRate resolve(int value) {
            switch (value) {
            case 1200: return Baud1200;
            case 2400: return Baud2400;
            case 4800: return Baud4800;
            case 9600: return Baud9600;
            case 19200: return Baud19200;
            case 38400: return Baud38400;
            case 57600: return Baud57600;
            case 115200: return Baud115200;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QSerialPort::DataBits
     */
    public enum DataBits implements QtEnumerator {
        /**
         * Representing QSerialPort::Data5
         */
        Data5(5),
        /**
         * Representing QSerialPort::Data6
         */
        Data6(6),
        /**
         * Representing QSerialPort::Data7
         */
        Data7(7),
        /**
         * Representing QSerialPort::Data8
         */
        Data8(8);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private DataBits(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull DataBits resolve(int value) {
            switch (value) {
            case 5: return Data5;
            case 6: return Data6;
            case 7: return Data7;
            case 8: return Data8;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QSerialPort::Direction
     * 
     * @see Directions
     */
    public enum Direction implements QtFlagEnumerator {
        /**
         * Representing QSerialPort::Input
         */
        Input(1),
        /**
         * Representing QSerialPort::Output
         */
        Output(2),
        /**
         * Representing QSerialPort::AllDirections
         */
        AllDirections(3);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private Direction(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        public @NonNull Directions asFlags() {
            return new Directions(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull Directions combined(@NonNull Direction e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull Directions cleared(@NonNull Direction e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link Directions} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull Directions flags(@Nullable Direction @NonNull... values) {
            return new Directions(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull Direction resolve(int value) {
            switch (value) {
            case 1: return Input;
            case 2: return Output;
            case 3: return AllDirections;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link Direction}
     */
    public static final class Directions extends QFlags implements Comparable {
        private static final long serialVersionUID = 0x71c569119b578844L;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new Directions where the flags in args are set.
         * @param args enum entries
         */
        public Directions(@Nullable Direction @NonNull... args){
            super(args);
        }

        /**
         * Creates a new Directions with given value.
         * @param value
         */
        public Directions(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new Directions
         */
        @Override
        public final @NonNull Directions combined(@StrictNonNull Direction e){
            return new Directions(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        public final @NonNull Directions setFlag(@Nullable Direction e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        public final @NonNull Directions setFlag(@Nullable Direction e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this Directions.
         * @return array of enum entries
         */
        @Override
        public final @NonNull Direction @NonNull[] flags(){
            return super.flags(Direction.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull Directions clone(){
            return new Directions(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull Directions other){
            return Integer.compare(value(), other.value());
        }
    }
    
    /**
     * Java wrapper for Qt enum QSerialPort::FlowControl
     */
    public enum FlowControl implements QtEnumerator {
        /**
         * Representing QSerialPort::NoFlowControl
         */
        NoFlowControl(0),
        /**
         * Representing QSerialPort::HardwareControl
         */
        HardwareControl(1),
        /**
         * Representing QSerialPort::SoftwareControl
         */
        SoftwareControl(2);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private FlowControl(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull FlowControl resolve(int value) {
            switch (value) {
            case 0: return NoFlowControl;
            case 1: return HardwareControl;
            case 2: return SoftwareControl;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QSerialPort::Parity
     */
    public enum Parity implements QtEnumerator {
        /**
         * Representing QSerialPort::NoParity
         */
        NoParity(0),
        /**
         * Representing QSerialPort::EvenParity
         */
        EvenParity(2),
        /**
         * Representing QSerialPort::OddParity
         */
        OddParity(3),
        /**
         * Representing QSerialPort::SpaceParity
         */
        SpaceParity(4),
        /**
         * Representing QSerialPort::MarkParity
         */
        MarkParity(5);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private Parity(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull Parity resolve(int value) {
            switch (value) {
            case 0: return NoParity;
            case 2: return EvenParity;
            case 3: return OddParity;
            case 4: return SpaceParity;
            case 5: return MarkParity;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QSerialPort::PinoutSignal
     * 
     * @see PinoutSignals
     */
    public enum PinoutSignal implements QtFlagEnumerator {
        /**
         * Representing QSerialPort::NoSignal
         */
        NoSignal(0),
        /**
         * Representing QSerialPort::DataTerminalReadySignal
         */
        DataTerminalReadySignal(4),
        /**
         * Representing QSerialPort::DataCarrierDetectSignal
         */
        DataCarrierDetectSignal(8),
        /**
         * Representing QSerialPort::DataSetReadySignal
         */
        DataSetReadySignal(16),
        /**
         * Representing QSerialPort::RingIndicatorSignal
         */
        RingIndicatorSignal(32),
        /**
         * Representing QSerialPort::RequestToSendSignal
         */
        RequestToSendSignal(64),
        /**
         * Representing QSerialPort::ClearToSendSignal
         */
        ClearToSendSignal(128),
        /**
         * Representing QSerialPort::SecondaryTransmittedDataSignal
         */
        SecondaryTransmittedDataSignal(256),
        /**
         * Representing QSerialPort::SecondaryReceivedDataSignal
         */
        SecondaryReceivedDataSignal(512);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private PinoutSignal(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        public @NonNull PinoutSignals asFlags() {
            return new PinoutSignals(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull PinoutSignals combined(@NonNull PinoutSignal e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull PinoutSignals cleared(@NonNull PinoutSignal e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link PinoutSignals} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull PinoutSignals flags(@Nullable PinoutSignal @NonNull... values) {
            return new PinoutSignals(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull PinoutSignal resolve(int value) {
            switch (value) {
            case 0: return NoSignal;
            case 4: return DataTerminalReadySignal;
            case 8: return DataCarrierDetectSignal;
            case 16: return DataSetReadySignal;
            case 32: return RingIndicatorSignal;
            case 64: return RequestToSendSignal;
            case 128: return ClearToSendSignal;
            case 256: return SecondaryTransmittedDataSignal;
            case 512: return SecondaryReceivedDataSignal;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link PinoutSignal}
     */
    public static final class PinoutSignals extends QFlags implements Comparable {
        private static final long serialVersionUID = 0x3ed147b32ddec402L;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new PinoutSignals where the flags in args are set.
         * @param args enum entries
         */
        public PinoutSignals(@Nullable PinoutSignal @NonNull... args){
            super(args);
        }

        /**
         * Creates a new PinoutSignals with given value.
         * @param value
         */
        public PinoutSignals(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new PinoutSignals
         */
        @Override
        public final @NonNull PinoutSignals combined(@StrictNonNull PinoutSignal e){
            return new PinoutSignals(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        public final @NonNull PinoutSignals setFlag(@Nullable PinoutSignal e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        public final @NonNull PinoutSignals setFlag(@Nullable PinoutSignal e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this PinoutSignals.
         * @return array of enum entries
         */
        @Override
        public final @NonNull PinoutSignal @NonNull[] flags(){
            return super.flags(PinoutSignal.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull PinoutSignals clone(){
            return new PinoutSignals(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull PinoutSignals other){
            return Integer.compare(value(), other.value());
        }
    }
    
    /**
     * Java wrapper for Qt enum QSerialPort::SerialPortError
     */
    public enum SerialPortError implements QtEnumerator {
        /**
         * Representing QSerialPort::NoError
         */
        NoError(0),
        /**
         * Representing QSerialPort::DeviceNotFoundError
         */
        DeviceNotFoundError(1),
        /**
         * Representing QSerialPort::PermissionError
         */
        PermissionError(2),
        /**
         * Representing QSerialPort::OpenError
         */
        OpenError(3),
        /**
         * Representing QSerialPort::WriteError
         */
        WriteError(4),
        /**
         * Representing QSerialPort::ReadError
         */
        ReadError(5),
        /**
         * Representing QSerialPort::ResourceError
         */
        ResourceError(6),
        /**
         * Representing QSerialPort::UnsupportedOperationError
         */
        UnsupportedOperationError(7),
        /**
         * Representing QSerialPort::UnknownError
         */
        UnknownError(8),
        /**
         * Representing QSerialPort::TimeoutError
         */
        TimeoutError(9),
        /**
         * Representing QSerialPort::NotOpenError
         */
        NotOpenError(10);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private SerialPortError(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull SerialPortError resolve(int value) {
            switch (value) {
            case 0: return NoError;
            case 1: return DeviceNotFoundError;
            case 2: return PermissionError;
            case 3: return OpenError;
            case 4: return WriteError;
            case 5: return ReadError;
            case 6: return ResourceError;
            case 7: return UnsupportedOperationError;
            case 8: return UnknownError;
            case 9: return TimeoutError;
            case 10: return NotOpenError;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QSerialPort::StopBits
     */
    public enum StopBits implements QtEnumerator {
        /**
         * Representing QSerialPort::OneStop
         */
        OneStop(1),
        /**
         * Representing QSerialPort::OneAndHalfStop
         */
        OneAndHalfStop(3),
        /**
         * Representing QSerialPort::TwoStop
         */
        TwoStop(2);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private StopBits(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull StopBits resolve(int value) {
            switch (value) {
            case 1: return OneStop;
            case 3: return OneAndHalfStop;
            case 2: return TwoStop;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    

    /**
     * See QSerialPort::baudRateChanged(qint32,QSerialPort::Directions)
     */
    @QtPropertyNotify(name="baudRate")
    public final @NonNull Signal2 baudRateChanged = new Signal2<>();

    /**
     * See QSerialPort::breakEnabledChanged(bool)
     */
    @QtPropertyNotify(name="breakEnabled")
    public final @NonNull Signal1 breakEnabledChanged = new Signal1<>();

    /**
     * See QSerialPort::dataBitsChanged(QSerialPort::DataBits)
     */
    @QtPropertyNotify(name="dataBits")
    public final @NonNull Signal1 dataBitsChanged = new Signal1<>();

    /**
     * See QSerialPort::dataTerminalReadyChanged(bool)
     */
    @QtPropertyNotify(name="dataTerminalReady")
    public final @NonNull Signal1 dataTerminalReadyChanged = new Signal1<>();

    /**
     * See QSerialPort::errorOccurred(QSerialPort::SerialPortError)
     */
    @QtPropertyNotify(name="error")
    public final @NonNull Signal1 errorOccurred = new Signal1<>();

    /**
     * See QSerialPort::flowControlChanged(QSerialPort::FlowControl)
     */
    @QtPropertyNotify(name="flowControl")
    public final @NonNull Signal1 flowControlChanged = new Signal1<>();

    /**
     * See QSerialPort::parityChanged(QSerialPort::Parity)
     */
    @QtPropertyNotify(name="parity")
    public final @NonNull Signal1 parityChanged = new Signal1<>();

    /**
     * See QSerialPort::requestToSendChanged(bool)
     */
    @QtPropertyNotify(name="requestToSend")
    public final @NonNull Signal1 requestToSendChanged = new Signal1<>();

    /**
     * See QSerialPort::stopBitsChanged(QSerialPort::StopBits)
     */
    @QtPropertyNotify(name="stopBits")
    public final @NonNull Signal1 stopBitsChanged = new Signal1<>();
    
    /**
     * See QSerialPort::QSerialPort(QObject*)
     */
    public QSerialPort(io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, parent);
    }
    
    private native static void initialize_native(QSerialPort instance, io.qt.core.QObject parent);
    
    /**
     * See QSerialPort::QSerialPort(QSerialPortInfo,QObject*)
     */
    public QSerialPort(io.qt.serialport.@NonNull QSerialPortInfo info, io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, info, parent);
    }
    
    private native static void initialize_native(QSerialPort instance, io.qt.serialport.QSerialPortInfo info, io.qt.core.QObject parent);
    
    /**
     * See QSerialPort::QSerialPort(QString,QObject*)
     */
    public QSerialPort(java.lang.@NonNull String name, io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, name, parent);
    }
    
    private native static void initialize_native(QSerialPort instance, java.lang.String name, io.qt.core.QObject parent);
    
    /**
     * See QSerialPort::baudRate(QSerialPort::Directions)const
     */
    @QtPropertyReader(name="baudRate")
    @QtUninvokable
    public final int baudRate(io.qt.serialport.QSerialPort.@NonNull Directions directions){
        return baudRate_native_QSerialPort_Directions_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), directions.value());
    }
    
    @QtUninvokable
    private native int baudRate_native_QSerialPort_Directions_constfct(long __this__nativeId, int directions);
    
    /**
     * See QSerialPort::bindableDataBits()
     */
    @QtPropertyBindable(name="dataBits")
    @QtUninvokable
    public final io.qt.core.@NonNull QBindable bindableDataBits(){
        return bindableDataBits_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QBindable bindableDataBits_native(long __this__nativeId);
    
    /**
     * See QSerialPort::bindableError()const
     */
    @QtPropertyBindable(name="error")
    @QtUninvokable
    public final io.qt.core.@NonNull QBindable bindableError(){
        return bindableError_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QBindable bindableError_native_constfct(long __this__nativeId);
    
    /**
     * See QSerialPort::bindableFlowControl()
     */
    @QtPropertyBindable(name="flowControl")
    @QtUninvokable
    public final io.qt.core.@NonNull QBindable bindableFlowControl(){
        return bindableFlowControl_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QBindable bindableFlowControl_native(long __this__nativeId);
    
    /**
     * See QSerialPort::bindableIsBreakEnabled()
     */
    @QtPropertyBindable(name="breakEnabled")
    @QtUninvokable
    public final io.qt.core.@NonNull QBooleanBindable bindableIsBreakEnabled(){
        return bindableIsBreakEnabled_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QBooleanBindable bindableIsBreakEnabled_native(long __this__nativeId);
    
    /**
     * See QSerialPort::bindableParity()
     */
    @QtPropertyBindable(name="parity")
    @QtUninvokable
    public final io.qt.core.@NonNull QBindable bindableParity(){
        return bindableParity_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QBindable bindableParity_native(long __this__nativeId);
    
    /**
     * See QSerialPort::bindableStopBits(Qt::Disambiguated_t)
     */
    @QtPropertyBindable(name="stopBits")
    @QtUninvokable
    public final io.qt.core.@NonNull QBindable bindableStopBits(){
        return bindableStopBits_native_Qt_Disambiguated_t(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QBindable bindableStopBits_native_Qt_Disambiguated_t(long __this__nativeId);
    
    /**
     * See QSerialPort::clear(QSerialPort::Directions)
     */
    @QtUninvokable
    public final boolean clear(io.qt.serialport.QSerialPort.@NonNull Directions directions){
        return clear_native_QSerialPort_Directions(QtJambi_LibraryUtilities.internal.nativeId(this), directions.value());
    }
    
    @QtUninvokable
    private native boolean clear_native_QSerialPort_Directions(long __this__nativeId, int directions);
    
    /**
     * See QSerialPort::clearError()
     */
    @QtPropertyResetter(name="error")
    @QtUninvokable
    public final void clearError(){
        clearError_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void clearError_native(long __this__nativeId);
    
    /**
     * See QSerialPort::dataBits()const
     */
    @QtPropertyReader(name="dataBits")
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull DataBits dataBits(){
        return io.qt.serialport.QSerialPort.DataBits.resolve(dataBits_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int dataBits_native_constfct(long __this__nativeId);
    
    /**
     * See QSerialPort::error()const
     */
    @QtPropertyReader(name="error")
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull SerialPortError error(){
        return io.qt.serialport.QSerialPort.SerialPortError.resolve(error_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int error_native_constfct(long __this__nativeId);
    
    /**
     * See QSerialPort::flowControl()const
     */
    @QtPropertyReader(name="flowControl")
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull FlowControl flowControl(){
        return io.qt.serialport.QSerialPort.FlowControl.resolve(flowControl_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int flowControl_native_constfct(long __this__nativeId);
    
    /**
     * See QSerialPort::flush()
     */
    @QtUninvokable
    public final boolean flush(){
        return flush_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean flush_native(long __this__nativeId);
    
    /**
     * See QSerialPort::isBreakEnabled()const
     */
    @QtPropertyReader(name="breakEnabled")
    @QtUninvokable
    public final boolean isBreakEnabled(){
        return isBreakEnabled_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isBreakEnabled_native_constfct(long __this__nativeId);
    
    /**
     * See QSerialPort::isDataTerminalReady()
     */
    @QtPropertyReader(name="dataTerminalReady")
    @QtUninvokable
    public final boolean isDataTerminalReady(){
        return isDataTerminalReady_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isDataTerminalReady_native(long __this__nativeId);
    
    /**
     * See QSerialPort::isRequestToSend()
     */
    @QtPropertyReader(name="requestToSend")
    @QtUninvokable
    public final boolean isRequestToSend(){
        return isRequestToSend_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isRequestToSend_native(long __this__nativeId);
    
    /**
     * See QSerialPort::parity()const
     */
    @QtPropertyReader(name="parity")
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull Parity parity(){
        return io.qt.serialport.QSerialPort.Parity.resolve(parity_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int parity_native_constfct(long __this__nativeId);
    
    /**
     * See QSerialPort::pinoutSignals()
     */
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull PinoutSignals pinoutSignals(){
        return new io.qt.serialport.QSerialPort.PinoutSignals(pinoutSignals_native(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int pinoutSignals_native(long __this__nativeId);
    
    /**
     * See QSerialPort::portName()const
     */
    @QtUninvokable
    public final java.lang.@NonNull String portName(){
        return portName_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.lang.String portName_native_constfct(long __this__nativeId);
    
    /**
     * See QSerialPort::readBufferSize()const
     */
    @QtUninvokable
    public final long readBufferSize(){
        return readBufferSize_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long readBufferSize_native_constfct(long __this__nativeId);
    
    /**
     * See QSerialPort::setBaudRate(qint32,QSerialPort::Directions)
     */
    @QtPropertyWriter(name="baudRate")
    @QtUninvokable
    public final boolean setBaudRate(int baudRate, io.qt.serialport.QSerialPort.@NonNull Directions directions){
        return setBaudRate_native_qint32_QSerialPort_Directions(QtJambi_LibraryUtilities.internal.nativeId(this), baudRate, directions.value());
    }
    
    @QtUninvokable
    private native boolean setBaudRate_native_qint32_QSerialPort_Directions(long __this__nativeId, int baudRate, int directions);
    
    /**
     * See QSerialPort::setBreakEnabled(bool)
     */
    @QtPropertyWriter(name="breakEnabled")
    @QtUninvokable
    public final boolean setBreakEnabled(boolean set){
        return setBreakEnabled_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), set);
    }
    
    @QtUninvokable
    private native boolean setBreakEnabled_native_bool(long __this__nativeId, boolean set);
    
    /**
     * See QSerialPort::setDataBits(QSerialPort::DataBits)
     */
    @QtPropertyWriter(name="dataBits")
    @QtUninvokable
    public final boolean setDataBits(io.qt.serialport.QSerialPort.@NonNull DataBits dataBits){
        return setDataBits_native_QSerialPort_DataBits(QtJambi_LibraryUtilities.internal.nativeId(this), dataBits.value());
    }
    
    @QtUninvokable
    private native boolean setDataBits_native_QSerialPort_DataBits(long __this__nativeId, int dataBits);
    
    /**
     * See QSerialPort::setDataTerminalReady(bool)
     */
    @QtPropertyWriter(name="dataTerminalReady")
    @QtUninvokable
    public final boolean setDataTerminalReady(boolean set){
        return setDataTerminalReady_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), set);
    }
    
    @QtUninvokable
    private native boolean setDataTerminalReady_native_bool(long __this__nativeId, boolean set);
    
    /**
     * See QSerialPort::setFlowControl(QSerialPort::FlowControl)
     */
    @QtPropertyWriter(name="flowControl")
    @QtUninvokable
    public final boolean setFlowControl(io.qt.serialport.QSerialPort.@NonNull FlowControl flowControl){
        return setFlowControl_native_QSerialPort_FlowControl(QtJambi_LibraryUtilities.internal.nativeId(this), flowControl.value());
    }
    
    @QtUninvokable
    private native boolean setFlowControl_native_QSerialPort_FlowControl(long __this__nativeId, int flowControl);
    
    /**
     * See QSerialPort::setParity(QSerialPort::Parity)
     */
    @QtPropertyWriter(name="parity")
    @QtUninvokable
    public final boolean setParity(io.qt.serialport.QSerialPort.@NonNull Parity parity){
        return setParity_native_QSerialPort_Parity(QtJambi_LibraryUtilities.internal.nativeId(this), parity.value());
    }
    
    @QtUninvokable
    private native boolean setParity_native_QSerialPort_Parity(long __this__nativeId, int parity);
    
    /**
     * See QSerialPort::setPort(QSerialPortInfo)
     */
    @QtUninvokable
    public final void setPort(io.qt.serialport.@NonNull QSerialPortInfo info){
        setPort_native_cref_QSerialPortInfo(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(info));
    }
    
    @QtUninvokable
    private native void setPort_native_cref_QSerialPortInfo(long __this__nativeId, long info);
    
    /**
     * See QSerialPort::setPortName(QString)
     */
    @QtUninvokable
    public final void setPortName(java.lang.@NonNull String name){
        setPortName_native_cref_QString(QtJambi_LibraryUtilities.internal.nativeId(this), name);
    }
    
    @QtUninvokable
    private native void setPortName_native_cref_QString(long __this__nativeId, java.lang.String name);
    
    /**
     * See QSerialPort::setReadBufferSize(qint64)
     */
    @QtUninvokable
    public final void setReadBufferSize(long size){
        setReadBufferSize_native_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), size);
    }
    
    @QtUninvokable
    private native void setReadBufferSize_native_qint64(long __this__nativeId, long size);
    
    /**
     * See QSerialPort::setRequestToSend(bool)
     */
    @QtPropertyWriter(name="requestToSend")
    @QtUninvokable
    public final boolean setRequestToSend(boolean set){
        return setRequestToSend_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), set);
    }
    
    @QtUninvokable
    private native boolean setRequestToSend_native_bool(long __this__nativeId, boolean set);
    
    /**
     * See QSerialPort::setStopBits(QSerialPort::StopBits)
     */
    @QtPropertyWriter(name="stopBits")
    @QtUninvokable
    public final boolean setStopBits(io.qt.serialport.QSerialPort.@NonNull StopBits stopBits){
        return setStopBits_native_QSerialPort_StopBits(QtJambi_LibraryUtilities.internal.nativeId(this), stopBits.value());
    }
    
    @QtUninvokable
    private native boolean setStopBits_native_QSerialPort_StopBits(long __this__nativeId, int stopBits);
    
    /**
     * See QSerialPort::stopBits()const
     */
    @QtPropertyReader(name="stopBits")
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull StopBits stopBits(){
        return io.qt.serialport.QSerialPort.StopBits.resolve(stopBits_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int stopBits_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::bytesAvailable()const
     */
    @QtUninvokable
    @Override
    public long bytesAvailable(){
        return bytesAvailable_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long bytesAvailable_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::bytesToWrite()const
     */
    @QtUninvokable
    @Override
    public long bytesToWrite(){
        return bytesToWrite_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long bytesToWrite_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::canReadLine()const
     */
    @QtUninvokable
    @Override
    public boolean canReadLine(){
        return canReadLine_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean canReadLine_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::close()
     */
    @QtUninvokable
    @Override
    public void close(){
        close_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void close_native(long __this__nativeId);
    
    /**
     * See QIODevice::isSequential()const
     */
    @QtUninvokable
    @Override
    public boolean isSequential(){
        return isSequential_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isSequential_native_constfct(long __this__nativeId);
    
    /**
     * See QIODevice::open(QIODeviceBase::OpenMode)
     */
    @QtUninvokable
    @Override
    public boolean open(io.qt.core.QIODeviceBase.@NonNull OpenMode mode){
        return open_native_QIODeviceBase_OpenMode(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    @QtUninvokable
    private native boolean open_native_QIODeviceBase_OpenMode(long __this__nativeId, int mode);
    
    /**
     * See QIODevice::readData(char*,qint64)
     */
    @QtUninvokable
    @Override
    protected int readData(java.nio.@Nullable ByteBuffer data){
        return readData_native_char_ptr_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), data);
    }
    
    @QtUninvokable
    private native int readData_native_char_ptr_qint64(long __this__nativeId, java.nio.ByteBuffer data);
    
    /**
     * See QIODevice::readLineData(char*,qint64)
     */
    @QtUninvokable
    @Override
    protected int readLineData(java.nio.@Nullable ByteBuffer data){
        return readLineData_native_char_ptr_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), data);
    }
    
    @QtUninvokable
    private native int readLineData_native_char_ptr_qint64(long __this__nativeId, java.nio.ByteBuffer data);
    
    /**
     * See QIODevice::waitForBytesWritten(int)
     */
    @QtUninvokable
    @Override
    public boolean waitForBytesWritten(int msecs){
        return waitForBytesWritten_native_int(QtJambi_LibraryUtilities.internal.nativeId(this), msecs);
    }
    
    @QtUninvokable
    private native boolean waitForBytesWritten_native_int(long __this__nativeId, int msecs);
    
    /**
     * See QIODevice::waitForReadyRead(int)
     */
    @QtUninvokable
    @Override
    public boolean waitForReadyRead(int msecs){
        return waitForReadyRead_native_int(QtJambi_LibraryUtilities.internal.nativeId(this), msecs);
    }
    
    @QtUninvokable
    private native boolean waitForReadyRead_native_int(long __this__nativeId, int msecs);
    
    /**
     * See QIODevice::writeData(const char*,qint64)
     */
    @QtUninvokable
    @Override
    protected int writeData(java.nio.@Nullable ByteBuffer data){
        return writeData_native_const_char_ptr_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), data);
    }
    
    @QtUninvokable
    private native int writeData_native_const_char_ptr_qint64(long __this__nativeId, java.nio.ByteBuffer data);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QSerialPort(QPrivateConstructor p) { super(p); } 
    
    /**
     * Constructor for internal use only.
     * It is not allowed to call the declarative constructor from inside Java.
     * @hidden
     */
    @NativeAccess
    protected QSerialPort(QDeclarativeConstructor constructor) {
        super((QPrivateConstructor)null);
        initialize_native(this, constructor);
    } 
    
    @QtUninvokable
    private static native void initialize_native(QSerialPort instance, QDeclarativeConstructor constructor);
    
    
    /**
     * Overloaded constructor for {@link #QSerialPort(io.qt.core.QObject)}
     *  with parent = null.
     */
    public QSerialPort() {
        this((io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded constructor for {@link #QSerialPort(io.qt.serialport.QSerialPortInfo, io.qt.core.QObject)}
     *  with parent = null.
     */
    public QSerialPort(io.qt.serialport.@NonNull QSerialPortInfo info) {
        this(info, (io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded constructor for {@link #QSerialPort(java.lang.String, io.qt.core.QObject)}
     *  with parent = null.
     */
    public QSerialPort(java.lang.@NonNull String name) {
        this(name, (io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded function for {@link #getBaudRate(io.qt.serialport.QSerialPort.Directions)}
     *  with directions = new io.qt.serialport.QSerialPort.Directions(3).
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int getBaudRate() {
        return getBaudRate(new io.qt.serialport.QSerialPort.Directions(3));
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #baudRate(io.qt.serialport.QSerialPort.Directions)} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int getBaudRate(io.qt.serialport.QSerialPort.@NonNull Directions directions) {
        return baudRate(directions);
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #baudRate(io.qt.serialport.QSerialPort.Directions)} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int getBaudRate(io.qt.serialport.QSerialPort.@NonNull Direction @NonNull... directions) {
        return baudRate(new io.qt.serialport.QSerialPort.Directions(directions));
    }
    
    /**
     * Overloaded function for {@link #baudRate(io.qt.serialport.QSerialPort.Directions)}
     *  with directions = new io.qt.serialport.QSerialPort.Directions(3).
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int baudRate() {
        return baudRate(new io.qt.serialport.QSerialPort.Directions(3));
    }
    
    /**
     * Overloaded function for {@link #baudRate(io.qt.serialport.QSerialPort.Directions)} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int baudRate(io.qt.serialport.QSerialPort.@NonNull Direction @NonNull... directions) {
        return baudRate(new io.qt.serialport.QSerialPort.Directions(directions));
    }
    
    /**
     * Overloaded function for {@link #clear(io.qt.serialport.QSerialPort.Directions)}
     *  with directions = new io.qt.serialport.QSerialPort.Directions(3).
     */
    @QtUninvokable
    public final boolean clear() {
        return clear(new io.qt.serialport.QSerialPort.Directions(3));
    }
    
    /**
     * Overloaded function for {@link #clear(io.qt.serialport.QSerialPort.Directions)}.
     */
    @QtUninvokable
    public final boolean clear(io.qt.serialport.QSerialPort.@NonNull Direction @NonNull... directions) {
        return clear(new io.qt.serialport.QSerialPort.Directions(directions));
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #dataBits()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull DataBits getDataBits() {
        return dataBits();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #error()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull SerialPortError getError() {
        return error();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #flowControl()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull FlowControl getFlowControl() {
        return flowControl();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #isBreakEnabled()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final boolean getBreakEnabled() {
        return isBreakEnabled();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #isDataTerminalReady()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final boolean getDataTerminalReady() {
        return isDataTerminalReady();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #isRequestToSend()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final boolean getRequestToSend() {
        return isRequestToSend();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #parity()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull Parity getParity() {
        return parity();
    }
    
    /**
     * Overloaded function for {@link #setBaudRate(int, io.qt.serialport.QSerialPort.Directions)}
     *  with directions = new io.qt.serialport.QSerialPort.Directions(3).
     */
    @QtUninvokable
    public final boolean setBaudRate(int baudRate) {
        return setBaudRate(baudRate, new io.qt.serialport.QSerialPort.Directions(3));
    }
    
    /**
     * Overloaded function for {@link #setBaudRate(int, io.qt.serialport.QSerialPort.Directions)}.
     */
    @QtUninvokable
    public final boolean setBaudRate(int baudRate, io.qt.serialport.QSerialPort.@NonNull Direction @NonNull... directions) {
        return setBaudRate(baudRate, new io.qt.serialport.QSerialPort.Directions(directions));
    }
    
    /**
     * Overloaded function for {@link #setBreakEnabled(boolean)}
     *  with set = true.
     */
    @QtUninvokable
    public final boolean setBreakEnabled() {
        return setBreakEnabled((boolean)true);
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #stopBits()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.serialport.QSerialPort.@NonNull StopBits getStopBits() {
        return stopBits();
    }
}