}

    /**
     * Sets additional information flags for the query
     *
     * @param additionalInformation
     *            the additionalInformation to set
     */
    public final void setAdditionalInformation(final int additionalInformation) {
        this.additionalInformation = additionalInformation;
    }

    /**
     * Sets the query flags for the information request
     *
     * @param queryFlags

 VersionID [16]byte  // Version UUID, raw.
 ModTime   int64     // Unix nanoseconds.
 Signature [4]byte   // Signature of metadata.
 Type      uint8     // Type if the version
 Flags     uint8
}
```

The following flags are defined:

```
const (
 FreeVersion = 1 << 0
 UsesDataDir = 1 << 1
 InlineData  = 1 << 2
)
```

     * @return the granted lease state
     */
    public int getLeaseState() {
        return leaseState;
    }

    /**
     * Gets the lease flags from the server response
     * @return the lease flags
     */
    public int getLeaseFlags() {
        return leaseFlags;
    }

    @Override

    private final byte[] serverGuid = new byte[16];
    private int securityMode;
    private int dialect;

    /**
     * Gets the server capabilities
     *
     * @return the capabilities flags from the server
     */
    public int getCapabilities() {
        return this.capabilities;
    }

    /**
     * Gets the server GUID
     *
     * @return the server's unique identifier
     */

     * @param off the start offset in the data
     * @param len the number of bytes to write
     * @param flags write operation flags
     * @throws IOException if an I/O error occurs
     */
    public void writeDirect(final byte[] b, int off, int len, final int flags) throws IOException {
        if (len <= 0) {
            return;
        }

        if (this.tmp == null) {

            send(new SmbComOpenAndX(unc, access, flags, null), response);
            f = response.fid;
        }

        return f;
    }

    void open(final int flags, final int access, final int attrs, final int options) throws SmbException {
        if (isOpen()) {
            return;
        }
        fid = open0(flags, access, attrs, options);
        opened = true;

		return v > 0
	}
	// On ID mismatch
	if v := bytes.Compare(x.VersionID[:], o.VersionID[:]); v != 0 {
		return v > 0
	}
	// Flags
	if x.Flags != o.Flags {
		return x.Flags > o.Flags
	}
	return false
}

func (j xlMetaV2Version) getDataDir() string {
	if j.Valid() {
		switch j.Type {
		case LegacyType:
			return j.ObjectV1.DataDir

	// as UTF-8, they will need to set the flag bit themselves.
	utf8Valid1, utf8Require1 := detectUTF8(fh.Name)
	utf8Valid2, utf8Require2 := detectUTF8(fh.Comment)
	switch {
	case fh.NonUTF8:
		fh.Flags &^= 0x800
	case (utf8Require1 || utf8Require2) && (utf8Valid1 && utf8Valid2):
		fh.Flags |= 0x800
	}

                ACE.FLAGS_INHERITED })
        @DisplayName("Flag constants should be powers of 2")
        void shouldBeValidFlagPowersOfTwo(int flag) {
            assertTrue(flag > 0, "Flag should be positive");
            assertEquals(0, flag & (flag - 1), "Flag should be power of 2: " + Integer.toHexString(flag));
        }

        @Test
        @DisplayName("Should validate all constants are unique")

// this behavior.
func adminMiddleware(f http.HandlerFunc, flags ...hFlag) http.HandlerFunc {
	// Collect all flags with bitwise-OR and assign operator
	var handlerFlags hFlag
	for _, flag := range flags {
		handlerFlags |= flag
	}

	// Get name of the handler using reflection.
	handlerName := getHandlerName(f, "adminAPIHandlers")

	var handler http.HandlerFunc = func(w http.ResponseWriter, r *http.Request) {