}

        }
    }

    /**
     * Retrieves the access result data from an OpenSearch access result.
     * Handles exceptions that may occur during data retrieval.
     *
     * @param accessResult the access result to extract data from
     * @return the access result data, or null if retrieval fails
     */

            @Override
            public byte[] getData() {
                return data;
            }

            @Override
            public String getDataAsString() {
                return new String(data);
            }

            @Override
            public void setData(byte[] data) {
                this.data = data;
            }

            @Override
            public String getEncoding() {

- **Size of Serialized Data:**
Java serialization tends to produce larger serialized objects because it includes class metadata and other overhead.

- **Flexibility and Control:**
Java serialization offers limited control over the serialization process, such as excluding certain fields, customizing naming conventions, and handling complex data structures more gracefully.

- **Security:**

            generated OpenAPI, but currently it doesn't affect the parsing of the data.
            """
        ),
    ] = "multipart/form-data",
    alias: Annotated[
        Optional[str],
        Doc(
            """
            An alternative name for the parameter field.

            This will be used to extract the data and for the generated OpenAPI.

`JSONResponse` itself is a sub-class of `Response`.

///

And when you return a `Response`, **FastAPI** will pass it directly.

It won't do any data conversion with Pydantic models, it won't convert the contents to any type, etc.

This gives you a lot of flexibility. You can return any data type, override any data declaration or validation, etc.

## Using the `jsonable_encoder` in a `Response` { #using-the-jsonable-encoder-in-a-response }

 */
package jcifs.pac;

/**
 * Represents a Unicode string structure as used in PAC data.
 * This class encapsulates the metadata for a Unicode string including its length,
 * maximum length, and pointer to the actual string data.
 */
public class PacUnicodeString {

    private final short length;
    private final short maxLength;
    private final int pointer;

    public String available;

    /** Search/filter parameter for data configuration sort order. */
    public String sortOrder;

    /** Search/filter parameter for data configuration creator. */
    public String createdBy;

    /** Search/filter parameter for data configuration creation time. */
    public String createdTime;

    /**
     * Send data using RDMA
     *
     * @param data data buffer to send
     * @param region registered memory region for the data
     * @throws IOException if send fails
     */
    public abstract void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException;

    /**
     * Receive data using RDMA
     *
     * @param timeout timeout in milliseconds

			if !metaArr[index].InlineData() {
				// If the data is not inlined, we may end up incorrectly
				// inlining the data here, that leads to an inconsistent
				// situation where some objects are were not inlined
				// were now inlined, make sure to `nil` the Data such
				// that xl.meta is written as expected.
				metaArr[index].Data = nil
			}
			metaArr[index].Metadata = srcInfo.UserDefined

    }

    private String maskSensitiveData(String data) {
        if (data == null || !maskSensitiveData) {
            return data;
        }

        // Performance optimization: skip expensive regex for high-frequency logging
        if (enableHighPerformanceMode) {
            // Fast path: only check for obvious patterns without regex
            String lowerData = data.toLowerCase();