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

Show more of this group Show more artifacts with this name
Show all versions of qtjambi-serialbus Show documentation
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
package io.qt.serialbus;

import io.qt.*;


/**
 * Container class representing a single CAN frame
 * Java wrapper for Qt class QCanBusFrame
 */
public class QCanBusFrame extends QtObject
    implements java.lang.Cloneable
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * Java wrapper for Qt enum QCanBusFrame::FrameError
     * 
     * @see FrameErrors
     */
    public enum FrameError implements QtFlagEnumerator {
        /**
         * Representing QCanBusFrame::NoError
         */
        NoError(0),
        /**
         * Representing QCanBusFrame::TransmissionTimeoutError
         */
        TransmissionTimeoutError(1),
        /**
         * Representing QCanBusFrame::LostArbitrationError
         */
        LostArbitrationError(2),
        /**
         * Representing QCanBusFrame::ControllerError
         */
        ControllerError(4),
        /**
         * Representing QCanBusFrame::ProtocolViolationError
         */
        ProtocolViolationError(8),
        /**
         * Representing QCanBusFrame::TransceiverError
         */
        TransceiverError(16),
        /**
         * Representing QCanBusFrame::MissingAcknowledgmentError
         */
        MissingAcknowledgmentError(32),
        /**
         * Representing QCanBusFrame::BusOffError
         */
        BusOffError(64),
        /**
         * Representing QCanBusFrame::BusError
         */
        BusError(128),
        /**
         * Representing QCanBusFrame::ControllerRestartError
         */
        ControllerRestartError(256),
        /**
         * Representing QCanBusFrame::UnknownError
         */
        UnknownError(512),
        /**
         * Representing QCanBusFrame::AnyError
         */
        AnyError(536870911);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

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

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

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

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

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

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull FrameError resolve(int value) {
            switch (value) {
            case 0: return NoError;
            case 1: return TransmissionTimeoutError;
            case 2: return LostArbitrationError;
            case 4: return ControllerError;
            case 8: return ProtocolViolationError;
            case 16: return TransceiverError;
            case 32: return MissingAcknowledgmentError;
            case 64: return BusOffError;
            case 128: return BusError;
            case 256: return ControllerRestartError;
            case 512: return UnknownError;
            case 536870911: return AnyError;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


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

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

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

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

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        @Override
        public final @NonNull FrameErrors setFlag(@Nullable FrameError 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 FrameErrors setFlag(@Nullable FrameError 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 FrameErrors.
         * @return array of enum entries
         */
        @Override
        public final @NonNull FrameError @NonNull[] flags(){
            return super.flags(FrameError.values());
        }

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

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull FrameErrors other){
            return Integer.compare(value(), other.value());
        }
    }
    
    /**
     * Java wrapper for Qt enum QCanBusFrame::FrameType
     */
    public enum FrameType implements QtEnumerator {
        /**
         * Representing QCanBusFrame::UnknownFrame
         */
        UnknownFrame(0),
        /**
         * Representing QCanBusFrame::DataFrame
         */
        DataFrame(1),
        /**
         * Representing QCanBusFrame::ErrorFrame
         */
        ErrorFrame(2),
        /**
         * Representing QCanBusFrame::RemoteRequestFrame
         */
        RemoteRequestFrame(3),
        /**
         * Representing QCanBusFrame::InvalidFrame
         */
        InvalidFrame(4);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private FrameType(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 FrameType resolve(int value) {
            switch (value) {
            case 0: return UnknownFrame;
            case 1: return DataFrame;
            case 2: return ErrorFrame;
            case 3: return RemoteRequestFrame;
            case 4: return InvalidFrame;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    

    /**
     * Timestamp information with microsecond precision
     * Java wrapper for Qt class QCanBusFrame::TimeStamp
     */
    public static class TimeStamp extends QtObject
        implements java.lang.Cloneable
    {
        static {
            QtJambi_LibraryUtilities.initialize();
        }
        
        
        /**
         * See QCanBusFrame::TimeStamp::TimeStamp(QCanBusFrame::TimeStamp)
         */
        public TimeStamp(io.qt.serialbus.QCanBusFrame.@NonNull TimeStamp other){
            super((QPrivateConstructor)null);
            initialize_native(this, other);
        }
        
        private native static void initialize_native(TimeStamp instance, io.qt.serialbus.QCanBusFrame.TimeStamp other);
        
        /**
         * See QCanBusFrame::TimeStamp::TimeStamp(qint64,qint64)
         */
        public TimeStamp(long s, long usec){
            super((QPrivateConstructor)null);
            initialize_native(this, s, usec);
        }
        
        private native static void initialize_native(TimeStamp instance, long s, long usec);
        
        /**
         * See QCanBusFrame::TimeStamp::microSeconds()const
         */
        @QtUninvokable
        public final long microSeconds(){
            return microSeconds_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native long microSeconds_native_constfct(long __this__nativeId);
        
        /**
         * See operator==(QCanBusFrame::TimeStamp,QCanBusFrame::TimeStamp)
         */
        @QtUninvokable
        public final boolean equals(io.qt.serialbus.QCanBusFrame.@NonNull TimeStamp value2){
            return equals_native_cref_QCanBusFrame_TimeStamp(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(value2));
        }
        
        @QtUninvokable
        private native boolean equals_native_cref_QCanBusFrame_TimeStamp(long __this__nativeId, long value2);
        
        /**
         * See QCanBusFrame::TimeStamp::seconds()const
         */
        @QtUninvokable
        public final long seconds(){
            return seconds_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        
        @QtUninvokable
        private native long seconds_native_constfct(long __this__nativeId);
        
        /**
         * See QCanBusFrame::TimeStamp::fromMicroSeconds(qint64)
         */
        public native static io.qt.serialbus.QCanBusFrame.@NonNull TimeStamp fromMicroSeconds(long usec);
        
        /**
         * Constructor for internal use only.
         * @param p expected to be null.
         * @hidden
         */
        @NativeAccess
        protected TimeStamp(QPrivateConstructor p) { super(p); } 
        

        /**
         * See operator==(QCanBusFrame::TimeStamp,QCanBusFrame::TimeStamp)
         */
        @Override
        @QtUninvokable
        public boolean equals(Object other) {
            if (other==null || other instanceof io.qt.serialbus.QCanBusFrame.TimeStamp) {
                return equals((io.qt.serialbus.QCanBusFrame.TimeStamp) other);
            }

            return false;
        }


        /**
         * Returns the objects's hash code computed by qHash(QCanBusFrame::TimeStamp).
         */
        @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 QCanBusFrame::TimeStamp::TimeStamp(QCanBusFrame::TimeStamp)
         */
        @QtUninvokable
        @Override
        public TimeStamp clone() {
            return clone_native(QtJambi_LibraryUtilities.internal.nativeId(this));
        }
        private static native TimeStamp clone_native(long __this_nativeId);
        
        /**
         * Overloaded constructor for {@link #TimeStamp(long, long)}
         *  with usec = 0.
         */
        public TimeStamp(long s) {
            this(s, (long)0);
        }
        
        /**
         * Overloaded constructor for {@link #TimeStamp(long, long)}
         * with: 

         * s = 0
         * usec = 0
         * 
         */
        public TimeStamp() {
            this((long)0, (long)0);
        }
    }

    
    /**
     * See QCanBusFrame::QCanBusFrame(QCanBusFrame)
     */
    public QCanBusFrame(io.qt.serialbus.@NonNull QCanBusFrame other){
        super((QPrivateConstructor)null);
        initialize_native(this, other);
    }
    
    private native static void initialize_native(QCanBusFrame instance, io.qt.serialbus.QCanBusFrame other);
    
    /**
     * See QCanBusFrame::QCanBusFrame(QCanBusFrame::FrameType)
     */
    public QCanBusFrame(io.qt.serialbus.QCanBusFrame.@NonNull FrameType type){
        super((QPrivateConstructor)null);
        initialize_native(this, type);
    }
    
    private native static void initialize_native(QCanBusFrame instance, io.qt.serialbus.QCanBusFrame.FrameType type);
    
    /**
     * See QCanBusFrame::QCanBusFrame(QCanBusFrame::FrameId,QByteArray)
     */
    public QCanBusFrame(int identifier, io.qt.core.@NonNull QByteArray data){
        super((QPrivateConstructor)null);
        initialize_native(this, identifier, data);
    }
    
    private native static void initialize_native(QCanBusFrame instance, int identifier, io.qt.core.QByteArray data);
    
    /**
     * See QCanBusFrame::error()const
     */
    @QtUninvokable
    public final io.qt.serialbus.QCanBusFrame.@NonNull FrameErrors error(){
        return new io.qt.serialbus.QCanBusFrame.FrameErrors(error_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int error_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::frameId()const
     */
    @QtUninvokable
    public final int frameId(){
        return frameId_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int frameId_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::frameType()const
     */
    @QtUninvokable
    public final io.qt.serialbus.QCanBusFrame.@NonNull FrameType frameType(){
        return io.qt.serialbus.QCanBusFrame.FrameType.resolve(frameType_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int frameType_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::hasBitrateSwitch()const
     */
    @QtUninvokable
    public final boolean hasBitrateSwitch(){
        return hasBitrateSwitch_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean hasBitrateSwitch_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::hasErrorStateIndicator()const
     */
    @QtUninvokable
    public final boolean hasErrorStateIndicator(){
        return hasErrorStateIndicator_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean hasErrorStateIndicator_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::hasExtendedFrameFormat()const
     */
    @QtUninvokable
    public final boolean hasExtendedFrameFormat(){
        return hasExtendedFrameFormat_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean hasExtendedFrameFormat_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::hasFlexibleDataRateFormat()const
     */
    @QtUninvokable
    public final boolean hasFlexibleDataRateFormat(){
        return hasFlexibleDataRateFormat_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean hasFlexibleDataRateFormat_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::hasLocalEcho()const
     */
    @QtUninvokable
    public final boolean hasLocalEcho(){
        return hasLocalEcho_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean hasLocalEcho_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::isValid()const
     */
    @QtUninvokable
    public final boolean isValid(){
        return isValid_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isValid_native_constfct(long __this__nativeId);
    
    /**
     * See operator<<(QDataStream&,QCanBusFrame)
     */
    @QtUninvokable
    public void writeTo(io.qt.core.@StrictNonNull QDataStream arg__1){
        java.util.Objects.requireNonNull(arg__1, "Argument 'arg__1': null not expected.");
        writeTo_native_ref_QDataStream(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1));
    }
    
    @QtUninvokable
    private native void writeTo_native_ref_QDataStream(long __this__nativeId, long arg__1);
    
    /**
     * See operator==(QCanBusFrame,QCanBusFrame)
     */
    @QtUninvokable
    public final boolean equals(io.qt.serialbus.@NonNull QCanBusFrame value2){
        return equals_native_cref_QCanBusFrame(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(value2));
    }
    
    @QtUninvokable
    private native boolean equals_native_cref_QCanBusFrame(long __this__nativeId, long value2);
    
    /**
     * See operator>>(QDataStream&,QCanBusFrame&)
     */
    @QtUninvokable
    public void readFrom(io.qt.core.@StrictNonNull QDataStream arg__1){
        java.util.Objects.requireNonNull(arg__1, "Argument 'arg__1': null not expected.");
        readFrom_native_ref_QDataStream(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1));
    }
    
    @QtUninvokable
    private native void readFrom_native_ref_QDataStream(long __this__nativeId, long arg__1);
    
    /**
     * See QCanBusFrame::payload()const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QByteArray payload(){
        return payload_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QByteArray payload_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::setBitrateSwitch(bool)
     */
    @QtUninvokable
    public final void setBitrateSwitch(boolean bitrateSwitch){
        setBitrateSwitch_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), bitrateSwitch);
    }
    
    @QtUninvokable
    private native void setBitrateSwitch_native_bool(long __this__nativeId, boolean bitrateSwitch);
    
    /**
     * See QCanBusFrame::setError(QCanBusFrame::FrameErrors)
     */
    @QtUninvokable
    public final void setError(io.qt.serialbus.QCanBusFrame.@NonNull FrameErrors e){
        setError_native_QCanBusFrame_FrameErrors(QtJambi_LibraryUtilities.internal.nativeId(this), e.value());
    }
    
    @QtUninvokable
    private native void setError_native_QCanBusFrame_FrameErrors(long __this__nativeId, int e);
    
    /**
     * See QCanBusFrame::setErrorStateIndicator(bool)
     */
    @QtUninvokable
    public final void setErrorStateIndicator(boolean errorStateIndicator){
        setErrorStateIndicator_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), errorStateIndicator);
    }
    
    @QtUninvokable
    private native void setErrorStateIndicator_native_bool(long __this__nativeId, boolean errorStateIndicator);
    
    /**
     * See QCanBusFrame::setExtendedFrameFormat(bool)
     */
    @QtUninvokable
    public final void setExtendedFrameFormat(boolean isExtended){
        setExtendedFrameFormat_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), isExtended);
    }
    
    @QtUninvokable
    private native void setExtendedFrameFormat_native_bool(long __this__nativeId, boolean isExtended);
    
    /**
     * See QCanBusFrame::setFlexibleDataRateFormat(bool)
     */
    @QtUninvokable
    public final void setFlexibleDataRateFormat(boolean isFlexibleData){
        setFlexibleDataRateFormat_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), isFlexibleData);
    }
    
    @QtUninvokable
    private native void setFlexibleDataRateFormat_native_bool(long __this__nativeId, boolean isFlexibleData);
    
    /**
     * See QCanBusFrame::setFrameId(QCanBusFrame::FrameId)
     */
    @QtUninvokable
    public final void setFrameId(int newFrameId){
        setFrameId_native_quint32(QtJambi_LibraryUtilities.internal.nativeId(this), newFrameId);
    }
    
    @QtUninvokable
    private native void setFrameId_native_quint32(long __this__nativeId, int newFrameId);
    
    /**
     * See QCanBusFrame::setFrameType(QCanBusFrame::FrameType)
     */
    @QtUninvokable
    public final void setFrameType(io.qt.serialbus.QCanBusFrame.@NonNull FrameType newFormat){
        setFrameType_native_QCanBusFrame_FrameType(QtJambi_LibraryUtilities.internal.nativeId(this), newFormat.value());
    }
    
    @QtUninvokable
    private native void setFrameType_native_QCanBusFrame_FrameType(long __this__nativeId, int newFormat);
    
    /**
     * See QCanBusFrame::setLocalEcho(bool)
     */
    @QtUninvokable
    public final void setLocalEcho(boolean localEcho){
        setLocalEcho_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), localEcho);
    }
    
    @QtUninvokable
    private native void setLocalEcho_native_bool(long __this__nativeId, boolean localEcho);
    
    /**
     * See QCanBusFrame::setPayload(QByteArray)
     */
    @QtUninvokable
    public final void setPayload(io.qt.core.@NonNull QByteArray data){
        setPayload_native_cref_QByteArray(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(data));
    }
    
    @QtUninvokable
    private native void setPayload_native_cref_QByteArray(long __this__nativeId, long data);
    
    /**
     * See QCanBusFrame::setTimeStamp(QCanBusFrame::TimeStamp)
     */
    @QtUninvokable
    public final void setTimeStamp(io.qt.serialbus.QCanBusFrame.@NonNull TimeStamp ts){
        setTimeStamp_native_QCanBusFrame_TimeStamp(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(ts));
    }
    
    @QtUninvokable
    private native void setTimeStamp_native_QCanBusFrame_TimeStamp(long __this__nativeId, long ts);
    
    /**
     * See QCanBusFrame::timeStamp()const
     */
    @QtUninvokable
    public final io.qt.serialbus.QCanBusFrame.@NonNull TimeStamp timeStamp(){
        return timeStamp_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.serialbus.QCanBusFrame.TimeStamp timeStamp_native_constfct(long __this__nativeId);
    
    /**
     * See QCanBusFrame::toString()const
     */
    @QtUninvokable
    public final java.lang.@NonNull String toString(){
        return toString_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.lang.String toString_native_constfct(long __this__nativeId);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QCanBusFrame(QPrivateConstructor p) { super(p); } 
    

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

        return false;
    }


    /**
     * Returns the objects's hash code computed by qHash(QCanBusFrame).
     */
    @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 QCanBusFrame::QCanBusFrame(QCanBusFrame)
     */
    @QtUninvokable
    @Override
    public QCanBusFrame clone() {
        return clone_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    private static native QCanBusFrame clone_native(long __this_nativeId);
    
    /**
     * Overloaded constructor for {@link #QCanBusFrame(io.qt.serialbus.QCanBusFrame.FrameType)}
     *  with type = io.qt.serialbus.QCanBusFrame.FrameType.DataFrame.
     */
    public QCanBusFrame() {
        this(io.qt.serialbus.QCanBusFrame.FrameType.DataFrame);
    }
    
    /**
     * Overloaded constructor for {@link #QCanBusFrame(int, io.qt.core.QByteArray)}.
     */
    public QCanBusFrame(int identifier, byte @NonNull[] data) {
        this(identifier, new io.qt.core.QByteArray(data));
    }
    
    /**
     * Overloaded function for {@link #setError(io.qt.serialbus.QCanBusFrame.FrameErrors)}.
     */
    @QtUninvokable
    public final void setError(io.qt.serialbus.QCanBusFrame.@NonNull FrameError @NonNull... e) {
        setError(new io.qt.serialbus.QCanBusFrame.FrameErrors(e));
    }
    
    /**
     * Overloaded function for {@link #setPayload(io.qt.core.QByteArray)}.
     */
    @QtUninvokable
    public final void setPayload(byte @NonNull[] data) {
        setPayload(new io.qt.core.QByteArray(data));
    }
}