All Downloads are FREE. Search and download functionalities are using the official Maven repository.

io.qt.serialbus.QCanBusDevice Maven / Gradle / Ivy

Go to download

Provides access to serial industrial bus interface. Currently the module supports the CAN bus and Modbus protocols.

There is a newer version: 6.7.2
Show newest version
package io.qt.serialbus;

import io.qt.*;


/**
 * 
The interface class for CAN bus

 * 
Java wrapper for Qt class QCanBusDevice

 */
public abstract class QCanBusDevice extends io.qt.core.QObject
{
    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(QCanBusDevice.class);
    
    @NativeAccess
    private static final class ConcreteWrapper extends QCanBusDevice {
        
        @NativeAccess
        private ConcreteWrapper(QPrivateConstructor p) { super(p); }
        
        @Override
        @QtUninvokable
        protected void close(){
            close_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        @QtUninvokable
        private native void close_native(long __this__nativeId);
        
        
        @Override
        @QtUninvokable
        public java.lang.@NonNull String interpretErrorFrame(io.qt.serialbus.@NonNull QCanBusFrame errorFrame){
            return interpretErrorFrame_native_cref_QCanBusFrame(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(errorFrame));
        }
        @QtUninvokable
        private native java.lang.String interpretErrorFrame_native_cref_QCanBusFrame(long __this__nativeId, long errorFrame);
        
        
        @Override
        @QtUninvokable
        protected boolean open(){
            return open_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        @QtUninvokable
        private native boolean open_native(long __this__nativeId);
        
        
        @Override
        @QtUninvokable
        public boolean writeFrame(io.qt.serialbus.@NonNull QCanBusFrame frame){
            return writeFrame_native_cref_QCanBusFrame(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(frame));
        }
        @QtUninvokable
        private native boolean writeFrame_native_cref_QCanBusFrame(long __this__nativeId, long frame);
        
    }
    
    /**
     * 
Java wrapper for Qt enum QCanBusDevice::CanBusDeviceState

     */
    public enum CanBusDeviceState implements QtEnumerator {
        /**
         * 
Representing QCanBusDevice::UnconnectedState

         */
        UnconnectedState(0),
        /**
         * 
Representing QCanBusDevice::ConnectingState

         */
        ConnectingState(1),
        /**
         * 
Representing QCanBusDevice::ConnectedState

         */
        ConnectedState(2),
        /**
         * 
Representing QCanBusDevice::ClosingState

         */
        ClosingState(3);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

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

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

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull CanBusDeviceState resolve(int value) {
            switch (value) {
            case 0: return UnconnectedState;
            case 1: return ConnectingState;
            case 2: return ConnectedState;
            case 3: return ClosingState;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * 
Java wrapper for Qt enum QCanBusDevice::CanBusError

     */
    public enum CanBusError implements QtEnumerator {
        /**
         * 
Representing QCanBusDevice::NoError

         */
        NoError(0),
        /**
         * 
Representing QCanBusDevice::ReadError

         */
        ReadError(1),
        /**
         * 
Representing QCanBusDevice::WriteError

         */
        WriteError(2),
        /**
         * 
Representing QCanBusDevice::ConnectionError

         */
        ConnectionError(3),
        /**
         * 
Representing QCanBusDevice::ConfigurationError

         */
        ConfigurationError(4),
        /**
         * 
Representing QCanBusDevice::UnknownError

         */
        UnknownError(5),
        /**
         * 
Representing QCanBusDevice::OperationError

         */
        OperationError(6),
        /**
         * 
Representing QCanBusDevice::TimeoutError

         */
        TimeoutError(7);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

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

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

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull CanBusError resolve(int value) {
            switch (value) {
            case 0: return NoError;
            case 1: return ReadError;
            case 2: return WriteError;
            case 3: return ConnectionError;
            case 4: return ConfigurationError;
            case 5: return UnknownError;
            case 6: return OperationError;
            case 7: return TimeoutError;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * 
Java wrapper for Qt enum QCanBusDevice::CanBusStatus

     */
    public enum CanBusStatus implements QtEnumerator {
        /**
         * 
Representing QCanBusDevice::CanBusStatus::Unknown

         */
        Unknown(0),
        /**
         * 
Representing QCanBusDevice::CanBusStatus::Good

         */
        Good(1),
        /**
         * 
Representing QCanBusDevice::CanBusStatus::Warning

         */
        Warning(2),
        /**
         * 
Representing QCanBusDevice::CanBusStatus::Error

         */
        Error(3),
        /**
         * 
Representing QCanBusDevice::CanBusStatus::BusOff

         */
        BusOff(4);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

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

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

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull CanBusStatus resolve(int value) {
            switch (value) {
            case 0: return Unknown;
            case 1: return Good;
            case 2: return Warning;
            case 3: return Error;
            case 4: return BusOff;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * 
Java wrapper for Qt enum QCanBusDevice::ConfigurationKey

     */
    public enum ConfigurationKey implements QtEnumerator {
        /**
         * 
Representing QCanBusDevice::RawFilterKey

         */
        RawFilterKey(0),
        /**
         * 
Representing QCanBusDevice::ErrorFilterKey

         */
        ErrorFilterKey(1),
        /**
         * 
Representing QCanBusDevice::LoopbackKey

         */
        LoopbackKey(2),
        /**
         * 
Representing QCanBusDevice::ReceiveOwnKey

         */
        ReceiveOwnKey(3),
        /**
         * 
Representing QCanBusDevice::BitRateKey

         */
        BitRateKey(4),
        /**
         * 
Representing QCanBusDevice::CanFdKey

         */
        CanFdKey(5),
        /**
         * 
Representing QCanBusDevice::DataBitRateKey

         */
        DataBitRateKey(6),
        /**
         * 
Representing QCanBusDevice::ProtocolKey

         */
        ProtocolKey(7),
        /**
         * 
Representing QCanBusDevice::UserKey

         */
        UserKey(30);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

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

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

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull ConfigurationKey resolve(int value) {
            switch (value) {
            case 0: return RawFilterKey;
            case 1: return ErrorFilterKey;
            case 2: return LoopbackKey;
            case 3: return ReceiveOwnKey;
            case 4: return BitRateKey;
            case 5: return CanFdKey;
            case 6: return DataBitRateKey;
            case 7: return ProtocolKey;
            case 30: return UserKey;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * 
Java wrapper for Qt enum QCanBusDevice::Direction

     * 
     * @see Directions
     */
    public enum Direction implements QtFlagEnumerator {
        /**
         * 
Representing QCanBusDevice::Input

         */
        Input(1),
        /**
         * 
Representing QCanBusDevice::Output

         */
        Output(2),
        /**
         * 
Representing QCanBusDevice::AllDirections

         */
        AllDirections(3);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

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

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

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        @Override
        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
         */
        @Override
        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
         */
        @Override
        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());
        }
    }
    

    /**
     * 
QCanBusDevice::Filter struct defines a filter for CAN bus frames

     * 
Java wrapper for Qt class QCanBusDevice::Filter

     */
    public static class Filter extends QtObject
        implements java.lang.Cloneable
    {
        static {
            QtJambi_LibraryUtilities.initialize();
        }
        
        /**
         * 
Java wrapper for Qt enum QCanBusDevice::Filter::FormatFilter

         * 
         * @see FormatFilters
         */
        public enum FormatFilter implements QtFlagEnumerator {
            /**
             * 
Representing QCanBusDevice::Filter::MatchBaseFormat

             */
            MatchBaseFormat(1),
            /**
             * 
Representing QCanBusDevice::Filter::MatchExtendedFormat

             */
            MatchExtendedFormat(2),
            /**
             * 
Representing QCanBusDevice::Filter::MatchBaseAndExtendedFormat

             */
            MatchBaseAndExtendedFormat(3);

            static {
                QtJambi_LibraryUtilities.initialize();
            }

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

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

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

            /**
             * Combines this entry with other enum entry.
             * @param e enum entry
             * @return new flag
             */
            public @NonNull FormatFilters combined(@NonNull FormatFilter 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 FormatFilters cleared(@NonNull FormatFilter e) {
                return asFlags().setFlag(e, false);
            }

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

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


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

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

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

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

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

            /**
             * Sets or clears the flag flag
             * @param e enum entry
             * @param on set (true) or clear (false)
             * @return this
             */
            @Override
            public final @NonNull FormatFilters setFlag(@Nullable FormatFilter 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 FormatFilters.
             * @return array of enum entries
             */
            @Override
            public final @NonNull FormatFilter @NonNull[] flags(){
                return super.flags(FormatFilter.values());
            }

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

            /**
             * {@inheritDoc}
             */
            @Override
            public final int compareTo(@StrictNonNull FormatFilters other){
                return Integer.compare(value(), other.value());
            }
        }
        
        
        /**
         * 
See QCanBusDevice::Filter::Filter()

         */
        public Filter(){
            super((QPrivateConstructor)null);
            initialize_native(this);
        }
        
        private native static void initialize_native(Filter instance);
        
        /**
         * 
See QCanBusDevice::Filter::Filter(QCanBusDevice::Filter)

         */
        public Filter(io.qt.serialbus.QCanBusDevice.@NonNull Filter other){
            super((QPrivateConstructor)null);
            initialize_native(this, other);
        }
        
        private native static void initialize_native(Filter instance, io.qt.serialbus.QCanBusDevice.Filter other);
        
        /**
         * 
See QCanBusDevice::Filter::Filter{quint32,quint32,QCanBusFrame::FrameType,QCanBusDevice::Filter::FormatFilter}

         */
        public Filter(int frameId, int frameIdMask, io.qt.serialbus.QCanBusFrame.@NonNull FrameType type, io.qt.serialbus.QCanBusDevice.Filter.@NonNull FormatFilter format){
            super((QPrivateConstructor)null);
            initialize_native(this, frameId, frameIdMask, type, format);
        }
        
        private native static void initialize_native(Filter instance, int frameId, int frameIdMask, io.qt.serialbus.QCanBusFrame.FrameType type, io.qt.serialbus.QCanBusDevice.Filter.FormatFilter format);
        
        /**
         * 
See operator==(QCanBusDevice::Filter,QCanBusDevice::Filter)

         */
        @QtUninvokable
        public final boolean equals(io.qt.serialbus.QCanBusDevice.@NonNull Filter b){
            return equals_native_cref_QCanBusDevice_Filter(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(b));
        }
        
        @QtUninvokable
        private native boolean equals_native_cref_QCanBusDevice_Filter(long __this__nativeId, long b);
        
        /**
         * 
Frame format of the matching CAN bus frame

         * 
See QCanBusDevice::Filter::format

         */
        @QtUninvokable
        public final void setFormat(io.qt.serialbus.QCanBusDevice.Filter.@NonNull FormatFilter format){
            setFormat_native_cref_QCanBusDevice_Filter_FormatFilter(QtJambi_LibraryUtilities.internal.nativeId(this), format.value());
        }
        
        @QtUninvokable
        private native void setFormat_native_cref_QCanBusDevice_Filter_FormatFilter(long __this__nativeId, int format);
        
        /**
         * 
Frame format of the matching CAN bus frame

         * 
See QCanBusDevice::Filter::format

         */
        @QtUninvokable
        public final io.qt.serialbus.QCanBusDevice.Filter.@NonNull FormatFilter format(){
            return io.qt.serialbus.QCanBusDevice.Filter.FormatFilter.resolve(format_native(QtJambi_LibraryUtilities.internal.nativeId(this)));
        }
        
        @QtUninvokable
        private native int format_native(long __this__nativeId);
        
        /**
         * 
Frame id used to filter the incoming frames

         * 
See QCanBusDevice::Filter::frameId

         */
        @QtUninvokable
        public final void setFrameId(int frameId){
            setFrameId_native_quint32(QtJambi_LibraryUtilities.internal.nativeId(this), frameId);
        }
        
        @QtUninvokable
        private native void setFrameId_native_quint32(long __this__nativeId, int frameId);
        
        /**
         * 
Frame id used to filter the incoming frames

         * 
See QCanBusDevice::Filter::frameId

         */
        @QtUninvokable
        public final int frameId(){
            return frameId_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native int frameId_native(long __this__nativeId);
        
        /**
         * 
Bit mask that is applied to the frame id of the filter and the received frame

         * 
See QCanBusDevice::Filter::frameIdMask

         */
        @QtUninvokable
        public final void setFrameIdMask(int frameIdMask){
            setFrameIdMask_native_quint32(QtJambi_LibraryUtilities.internal.nativeId(this), frameIdMask);
        }
        
        @QtUninvokable
        private native void setFrameIdMask_native_quint32(long __this__nativeId, int frameIdMask);
        
        /**
         * 
Bit mask that is applied to the frame id of the filter and the received frame

         * 
See QCanBusDevice::Filter::frameIdMask

         */
        @QtUninvokable
        public final int frameIdMask(){
            return frameIdMask_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native int frameIdMask_native(long __this__nativeId);
        
        /**
         * 
Of the frame to be filtered

         * 
See QCanBusDevice::Filter::type

         */
        @QtUninvokable
        public final void setType(io.qt.serialbus.QCanBusFrame.@NonNull FrameType type){
            setType_native_cref_QCanBusFrame_FrameType(QtJambi_LibraryUtilities.internal.nativeId(this), type.value());
        }
        
        @QtUninvokable
        private native void setType_native_cref_QCanBusFrame_FrameType(long __this__nativeId, int type);
        
        /**
         * 
Of the frame to be filtered

         * 
See QCanBusDevice::Filter::type

         */
        @QtUninvokable
        public final io.qt.serialbus.QCanBusFrame.@NonNull FrameType type(){
            return io.qt.serialbus.QCanBusFrame.FrameType.resolve(type_native(QtJambi_LibraryUtilities.internal.nativeId(this)));
        }
        
        @QtUninvokable
        private native int type_native(long __this__nativeId);
        
        /**
         * Constructor for internal use only.
         * @param p expected to be null.
         * @hidden
         */
        @NativeAccess
        protected Filter(QPrivateConstructor p) { super(p); } 
        

        /**
         * 
See operator==(QCanBusDevice::Filter,QCanBusDevice::Filter)

         */
        @Override
        @QtUninvokable
        public boolean equals(Object other) {
            if (other==null || other instanceof io.qt.serialbus.QCanBusDevice.Filter) {
                return equals((io.qt.serialbus.QCanBusDevice.Filter) other);
            }

            return false;
        }


        /**
         * Returns the objects's hash code computed by qHash(QCanBusDevice::Filter).
         */
        @QtUninvokable
        @Override
        public int hashCode() {
            return hashCode_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        @QtUninvokable
        private native static int hashCode_native(long __this_nativeId);
        
        /**
         * 
Creates and returns a copy of this object.

        
See QCanBusDevice::Filter::Filter(QCanBusDevice::Filter)

         */
        @QtUninvokable
        @Override
        public Filter clone() {
            return clone_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        private static native Filter clone_native(long __this_nativeId);
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #format()} instead.

         */
        @QtUninvokable
        public final io.qt.serialbus.QCanBusDevice.Filter.@NonNull FormatFilter getFormat() {
            return format();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #frameId()} instead.

         */
        @QtUninvokable
        public final int getFrameId() {
            return frameId();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #frameIdMask()} instead.

         */
        @QtUninvokable
        public final int getFrameIdMask() {
            return frameIdMask();
        }
        
        /**
         * @hidden
         * 
Kotlin property getter. In Java use {@link #type()} instead.

         */
        @QtUninvokable
        public final io.qt.serialbus.QCanBusFrame.@NonNull FrameType getType() {
            return type();
        }
    }


    /**
     * 
See QCanBusDevice::errorOccurred(QCanBusDevice::CanBusError)

     */
    public final @NonNull Signal1 errorOccurred = new Signal1<>();

    /**
     * 
See QCanBusDevice::framesReceived()

     */
    public final @NonNull Signal0 framesReceived = new Signal0();

    /**
     * 
See QCanBusDevice::framesWritten(qint64)

     */
    public final @NonNull Signal1 framesWritten = new Signal1<>();

    /**
     * 
See QCanBusDevice::stateChanged(QCanBusDevice::CanBusDeviceState)

     */
    public final @NonNull Signal1 stateChanged = new Signal1<>();
    
    /**
     * 
See QCanBusDevice::QCanBusDevice(QObject*)

     */
    public QCanBusDevice(io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, parent);
    }
    
    private native static void initialize_native(QCanBusDevice instance, io.qt.core.QObject parent);
    
    /**
     * 
See QCanBusDevice::clear(QCanBusDevice::Directions)

     */
    @QtUninvokable
    public final void clear(io.qt.serialbus.QCanBusDevice.@NonNull Directions direction){
        clear_native_QCanBusDevice_Directions(QtJambi_LibraryUtilities.internal.nativeId(this), direction.value());
    }
    
    @QtUninvokable
    private native void clear_native_QCanBusDevice_Directions(long __this__nativeId, int direction);
    
    /**
     * 
See QCanBusDevice::clearError()

     */
    @QtUninvokable
    protected final void clearError(){
        clearError_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void clearError_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::configurationKeys()const

     */
    @QtUninvokable
    public final io.qt.core.@NonNull QList configurationKeys(){
        return configurationKeys_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QList configurationKeys_native_constfct(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::configurationParameter(QCanBusDevice::ConfigurationKey)const

     */
    @QtUninvokable
    public final java.lang.Object configurationParameter(io.qt.serialbus.QCanBusDevice.@NonNull ConfigurationKey key){
        return configurationParameter_native_QCanBusDevice_ConfigurationKey_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), key.value());
    }
    
    @QtUninvokable
    private native java.lang.Object configurationParameter_native_QCanBusDevice_ConfigurationKey_constfct(long __this__nativeId, int key);
    
    /**
     * 
See QCanBusDevice::connectDevice()

     */
    @QtUninvokable
    public final boolean connectDevice(){
        return connectDevice_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean connectDevice_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::dequeueOutgoingFrame()

     */
    @QtUninvokable
    protected final io.qt.serialbus.@NonNull QCanBusFrame dequeueOutgoingFrame(){
        return dequeueOutgoingFrame_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.serialbus.QCanBusFrame dequeueOutgoingFrame_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::disconnectDevice()

     */
    @QtUninvokable
    public final void disconnectDevice(){
        disconnectDevice_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void disconnectDevice_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::enqueueOutgoingFrame(QCanBusFrame)

     */
    @QtUninvokable
    protected final void enqueueOutgoingFrame(io.qt.serialbus.@NonNull QCanBusFrame newFrame){
        enqueueOutgoingFrame_native_cref_QCanBusFrame(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(newFrame));
    }
    
    @QtUninvokable
    private native void enqueueOutgoingFrame_native_cref_QCanBusFrame(long __this__nativeId, long newFrame);
    
    /**
     * 
See QCanBusDevice::enqueueReceivedFrames(QList<QCanBusFrame>)

     */
    @QtUninvokable
    protected final void enqueueReceivedFrames(java.util.@NonNull Collection newFrames){
        enqueueReceivedFrames_native_cref_QList(QtJambi_LibraryUtilities.internal.nativeId(this), newFrames);
    }
    
    @QtUninvokable
    private native void enqueueReceivedFrames_native_cref_QList(long __this__nativeId, java.util.Collection newFrames);
    
    /**
     * 
See QCanBusDevice::error()const

     */
    @QtUninvokable
    public final io.qt.serialbus.QCanBusDevice.@NonNull CanBusError error(){
        return io.qt.serialbus.QCanBusDevice.CanBusError.resolve(error_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int error_native_constfct(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::errorString()const

     */
    @QtUninvokable
    public final java.lang.@NonNull String errorString(){
        return errorString_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.lang.String errorString_native_constfct(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::framesAvailable()const

     */
    @QtUninvokable
    public final long framesAvailable(){
        return framesAvailable_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long framesAvailable_native_constfct(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::framesToWrite()const

     */
    @QtUninvokable
    public final long framesToWrite(){
        return framesToWrite_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long framesToWrite_native_constfct(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::hasOutgoingFrames()const

     */
    @QtUninvokable
    protected final boolean hasOutgoingFrames(){
        return hasOutgoingFrames_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean hasOutgoingFrames_native_constfct(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::readAllFrames()

     */
    @QtUninvokable
    public final io.qt.core.@NonNull QList readAllFrames(){
        return readAllFrames_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QList readAllFrames_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::readFrame()

     */
    @QtUninvokable
    public final io.qt.serialbus.@NonNull QCanBusFrame readFrame(){
        return readFrame_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.serialbus.QCanBusFrame readFrame_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::setError(QString,QCanBusDevice::CanBusError)

     */
    @QtUninvokable
    protected final void setError(java.lang.@NonNull String errorText, io.qt.serialbus.QCanBusDevice.@NonNull CanBusError arg__2){
        setError_native_cref_QString_QCanBusDevice_CanBusError(QtJambi_LibraryUtilities.internal.nativeId(this), errorText, arg__2.value());
    }
    
    @QtUninvokable
    private native void setError_native_cref_QString_QCanBusDevice_CanBusError(long __this__nativeId, java.lang.String errorText, int arg__2);
    
    /**
     * 
See QCanBusDevice::setState(QCanBusDevice::CanBusDeviceState)

     */
    @QtUninvokable
    protected final void setState(io.qt.serialbus.QCanBusDevice.@NonNull CanBusDeviceState newState){
        setState_native_QCanBusDevice_CanBusDeviceState(QtJambi_LibraryUtilities.internal.nativeId(this), newState.value());
    }
    
    @QtUninvokable
    private native void setState_native_QCanBusDevice_CanBusDeviceState(long __this__nativeId, int newState);
    
    /**
     * 
See QCanBusDevice::state()const

     */
    @QtUninvokable
    public final io.qt.serialbus.QCanBusDevice.@NonNull CanBusDeviceState state(){
        return io.qt.serialbus.QCanBusDevice.CanBusDeviceState.resolve(state_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int state_native_constfct(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::busStatus()

     */
    @QtUninvokable
    public io.qt.serialbus.QCanBusDevice.@NonNull CanBusStatus busStatus(){
        return io.qt.serialbus.QCanBusDevice.CanBusStatus.resolve(busStatus_native(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int busStatus_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::close()

     */
    @QtUninvokable
    protected abstract void close();
    
    @QtUninvokable
    private native void close_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::deviceInfo()const

     * 
This function was introduced in Qt 6.2.

     */
    @QtUninvokable
    public io.qt.serialbus.@NonNull QCanBusDeviceInfo deviceInfo(){
        return deviceInfo_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.serialbus.QCanBusDeviceInfo deviceInfo_native_constfct(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::hasBusStatus()const

     */
    @QtUninvokable
    public boolean hasBusStatus(){
        return hasBusStatus_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean hasBusStatus_native_constfct(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::interpretErrorFrame(QCanBusFrame)

     */
    @QtUninvokable
    public abstract java.lang.@NonNull String interpretErrorFrame(io.qt.serialbus.@NonNull QCanBusFrame errorFrame);
    
    @QtUninvokable
    private native java.lang.String interpretErrorFrame_native_cref_QCanBusFrame(long __this__nativeId, long errorFrame);
    
    /**
     * 
See QCanBusDevice::open()

     */
    @QtUninvokable
    protected abstract boolean open();
    
    @QtUninvokable
    private native boolean open_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::resetController()

     */
    @QtUninvokable
    public void resetController(){
        resetController_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void resetController_native(long __this__nativeId);
    
    /**
     * 
See QCanBusDevice::setConfigurationParameter(QCanBusDevice::ConfigurationKey,QVariant)

     */
    @QtUninvokable
    public void setConfigurationParameter(io.qt.serialbus.QCanBusDevice.@NonNull ConfigurationKey key, java.lang.Object value){
        setConfigurationParameter_native_QCanBusDevice_ConfigurationKey_cref_QVariant(QtJambi_LibraryUtilities.internal.nativeId(this), key.value(), value);
    }
    
    @QtUninvokable
    private native void setConfigurationParameter_native_QCanBusDevice_ConfigurationKey_cref_QVariant(long __this__nativeId, int key, java.lang.Object value);
    
    /**
     * 
See QCanBusDevice::waitForFramesReceived(int)

     */
    @QtUninvokable
    public boolean waitForFramesReceived(int msecs){
        return waitForFramesReceived_native_int(QtJambi_LibraryUtilities.internal.nativeId(this), msecs);
    }
    
    @QtUninvokable
    private native boolean waitForFramesReceived_native_int(long __this__nativeId, int msecs);
    
    /**
     * 
See QCanBusDevice::waitForFramesWritten(int)

     */
    @QtUninvokable
    public boolean waitForFramesWritten(int msecs){
        return waitForFramesWritten_native_int(QtJambi_LibraryUtilities.internal.nativeId(this), msecs);
    }
    
    @QtUninvokable
    private native boolean waitForFramesWritten_native_int(long __this__nativeId, int msecs);
    
    /**
     * 
See QCanBusDevice::writeFrame(QCanBusFrame)

     */
    @QtUninvokable
    public abstract boolean writeFrame(io.qt.serialbus.@NonNull QCanBusFrame frame);
    
    @QtUninvokable
    private native boolean writeFrame_native_cref_QCanBusFrame(long __this__nativeId, long frame);
    
    /**
     * 
See QCanBusDevice::createDeviceInfo(QString,QString,QString,QString,QString,int,bool,bool)

     */
    protected native static io.qt.serialbus.@NonNull QCanBusDeviceInfo createDeviceInfo(java.lang.@NonNull String plugin, java.lang.@NonNull String name, java.lang.@NonNull String serialNumber, java.lang.@NonNull String description, java.lang.@NonNull String alias, int channel, boolean isVirtual, boolean isFlexibleDataRateCapable);
    
    /**
     * 
See QCanBusDevice::createDeviceInfo(QString,QString,bool,bool)

     */
    protected native static io.qt.serialbus.@NonNull QCanBusDeviceInfo createDeviceInfo(java.lang.@NonNull String plugin, java.lang.@NonNull String name, boolean isVirtual, boolean isFlexibleDataRateCapable);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QCanBusDevice(QPrivateConstructor p) { super(p); } 
    
    /**
     * Constructor for internal use only.
     * It is not allowed to call the declarative constructor from inside Java.
     * @hidden
     */
    @NativeAccess
    protected QCanBusDevice(QDeclarativeConstructor constructor) {
        super((QPrivateConstructor)null);
        initialize_native(this, constructor);
    } 
    
    @QtUninvokable
    private static native void initialize_native(QCanBusDevice instance, QDeclarativeConstructor constructor);
    
    
    /**
     * 
Overloaded constructor for {@link #QCanBusDevice(io.qt.core.QObject)}
     *  with parent = null.

     */
    public QCanBusDevice() {
        this((io.qt.core.QObject)null);
    }
    
    /**
     * 
Overloaded function for {@link #clear(io.qt.serialbus.QCanBusDevice.Directions)}
     *  with direction = new io.qt.serialbus.QCanBusDevice.Directions(io.qt.serialbus.QCanBusDevice.Direction.AllDirections).

     */
    @QtUninvokable
    public final void clear() {
        clear(new io.qt.serialbus.QCanBusDevice.Directions(io.qt.serialbus.QCanBusDevice.Direction.AllDirections));
    }
    
    /**
     * 
Overloaded function for {@link #clear(io.qt.serialbus.QCanBusDevice.Directions)}.

     */
    @QtUninvokable
    public final void clear(io.qt.serialbus.QCanBusDevice.@NonNull Direction @NonNull... direction) {
        clear(new io.qt.serialbus.QCanBusDevice.Directions(direction));
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy