querymsg.java

nesC写的heed算法

     */
    public void set_msgType(byte value) {
        setSIntElement(offsetBits_msgType(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'msgType'
     */
    public static int size_msgType() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'msgType'
     */
    public static int sizeBits_msgType() {
        return 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: numFields
    //   Field type: byte
    //   Offset (bits): 32
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'numFields' is signed (false).
     */
    public static boolean isSigned_numFields() {
        return false;
    }

    /**
     * Return whether the field 'numFields' is an array (false).
     */
    public static boolean isArray_numFields() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'numFields'
     */
    public static int offset_numFields() {
        return (32 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'numFields'
     */
    public static int offsetBits_numFields() {
        return 32;
    }

    /**
     * Return the value (as a byte) of the field 'numFields'
     */
    public byte get_numFields() {
        return (byte)getSIntElement(offsetBits_numFields(), 8);
    }

    /**
     * Set the value of the field 'numFields'
     */
    public void set_numFields(byte value) {
        setSIntElement(offsetBits_numFields(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'numFields'
     */
    public static int size_numFields() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'numFields'
     */
    public static int sizeBits_numFields() {
        return 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: numExprs
    //   Field type: byte
    //   Offset (bits): 40
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'numExprs' is signed (false).
     */
    public static boolean isSigned_numExprs() {
        return false;
    }

    /**
     * Return whether the field 'numExprs' is an array (false).
     */
    public static boolean isArray_numExprs() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'numExprs'
     */
    public static int offset_numExprs() {
        return (40 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'numExprs'
     */
    public static int offsetBits_numExprs() {
        return 40;
    }

    /**
     * Return the value (as a byte) of the field 'numExprs'
     */
    public byte get_numExprs() {
        return (byte)getSIntElement(offsetBits_numExprs(), 8);
    }

    /**
     * Set the value of the field 'numExprs'
     */
    public void set_numExprs(byte value) {
        setSIntElement(offsetBits_numExprs(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'numExprs'
     */
    public static int size_numExprs() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'numExprs'
     */
    public static int sizeBits_numExprs() {
        return 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: fromBuffer
    //   Field type: byte
    //   Offset (bits): 48
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'fromBuffer' is signed (false).
     */
    public static boolean isSigned_fromBuffer() {
        return false;
    }

    /**
     * Return whether the field 'fromBuffer' is an array (false).
     */
    public static boolean isArray_fromBuffer() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'fromBuffer'
     */
    public static int offset_fromBuffer() {
        return (48 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'fromBuffer'
     */
    public static int offsetBits_fromBuffer() {
        return 48;
    }

    /**
     * Return the value (as a byte) of the field 'fromBuffer'
     */
    public byte get_fromBuffer() {
        return (byte)getSIntElement(offsetBits_fromBuffer(), 8);
    }

    /**
     * Set the value of the field 'fromBuffer'
     */
    public void set_fromBuffer(byte value) {
        setSIntElement(offsetBits_fromBuffer(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'fromBuffer'
     */
    public static int size_fromBuffer() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'fromBuffer'
     */
    public static int sizeBits_fromBuffer() {
        return 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: fromCatalogBuffer
    //   Field type: byte
    //   Offset (bits): 56
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'fromCatalogBuffer' is signed (false).
     */
    public static boolean isSigned_fromCatalogBuffer() {
        return false;
    }

    /**
     * Return whether the field 'fromCatalogBuffer' is an array (false).
     */
    public static boolean isArray_fromCatalogBuffer() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'fromCatalogBuffer'
     */
    public static int offset_fromCatalogBuffer() {
        return (56 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'fromCatalogBuffer'
     */
    public static int offsetBits_fromCatalogBuffer() {
        return 56;
    }

    /**
     * Return the value (as a byte) of the field 'fromCatalogBuffer'
     */
    public byte get_fromCatalogBuffer() {
        return (byte)getUIntElement(offsetBits_fromCatalogBuffer(), 1);
    }

    /**
     * Set the value of the field 'fromCatalogBuffer'
     */
    public void set_fromCatalogBuffer(byte value) {
        setUIntElement(offsetBits_fromCatalogBuffer(), 1, value);
    }

    /**
     * Return the size, in bytes, of the field 'fromCatalogBuffer'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_fromCatalogBuffer() {
        return (1 / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'fromCatalogBuffer'
     */
    public static int sizeBits_fromCatalogBuffer() {
        return 1;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: hasEvent
    //   Field type: byte
    //   Offset (bits): 57
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'hasEvent' is signed (false).
     */
    public static boolean isSigned_hasEvent() {
        return false;
    }

    /**
     * Return whether the field 'hasEvent' is an array (false).
     */
    public static boolean isArray_hasEvent() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'hasEvent'
     * WARNING: This field is not byte-aligned (bit offset 57).
     */
    public static int offset_hasEvent() {
        return (57 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'hasEvent'
     */
    public static int offsetBits_hasEvent() {
        return 57;
    }

    /**
     * Return the value (as a byte) of the field 'hasEvent'
     */
    public byte get_hasEvent() {
        return (byte)getUIntElement(offsetBits_hasEvent(), 1);
    }

    /**
     * Set the value of the field 'hasEvent'
     */
    public void set_hasEvent(byte value) {
        setUIntElement(offsetBits_hasEvent(), 1, value);
    }

    /**
     * Return the size, in bytes, of the field 'hasEvent'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_hasEvent() {
        return (1 / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'hasEvent'
     */
    public static int sizeBits_hasEvent() {
        return 1;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: hasForClause
    //   Field type: byte
    //   Offset (bits): 58
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'hasForClause' is signed (false).
     */
    public static boolean isSigned_hasForClause() {
        return false;
    }

    /**
     * Return whether the field 'hasForClause' is an array (false).
     */
    public static boolean isArray_hasForClause() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'hasForClause'
     * WARNING: This field is not byte-aligned (bit offset 58).
     */
    public static int offset_hasForClause() {
        return (58 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'hasForClause'
     */
    public static int offsetBits_hasForClause() {
        return 58;
    }

    /**
     * Return the value (as a byte) of the field 'hasForClause'
     */
    public byte get_hasForClause() {
        return (byte)getUIntElement(offsetBits_hasForClause(), 1);
    }

    /**
     * Set the value of the field 'hasForClause'
     */
    public void set_hasForClause(byte value) {
        setUIntElement(offsetBits_hasForClause(), 1, value);
    }

    /**
     * Return the size, in bytes, of the field 'hasForClause'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_hasForClause() {
        return (1 / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'hasForClause'
     */
    public static int sizeBits_hasForClause() {
        return 1;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: bufferType
    //   Field type: byte
    //   Offset (bits): 59
    //   Size (bits): 5
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'bufferType' is signed (false).
     */
    public static boolean isSigned_bufferType() {
        return false;
    }

    /**
     * Return whether the field 'bufferType' is an array (false).
     */
    public static boolean isArray_bufferType() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'bufferType'
     * WARNING: This field is not byte-aligned (bit offset 59).
     */
    public static int offset_bufferType() {
        return (59 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'bufferType'
     */
    public static int offsetBits_bufferType() {
        return 59;
    }

    /**
     * Return the value (as a byte) of the field 'bufferType'
     */
    public byte get_bufferType() {
        return (byte)getUIntElement(offsetBits_bufferType(), 5);
    }

    /**
     * Set the value of the field 'bufferType'
     */
    public void set_bufferType(byte value) {
        setUIntElement(offsetBits_bufferType(), 5, value);
    }

    /**
     * Return the size, in bytes, of the field 'bufferType'
     * WARNING: This field is not an even-sized number of bytes (5 bits).
     */
    public static int size_bufferType() {
        return (5 / 8) + 1;
    }