// Create response with data from RDMA buffer
            Smb2ReadResponse response = new Smb2ReadResponse();
            response.setData(readBuffer.array(), 0, request.getLength());
            
            // Notify waiting thread
            request.setResponse(response);
            
        } finally {
            readRegion.close();

    /** Array of fields to be included in standard search response */
    protected String[] responseFields;

    /** Array of fields to be included in scroll search response */
    protected String[] scrollResponseFields;

    /** Array of fields to be included in cache search response */
    protected String[] cacheResponseFields;

    /** Array of fields that can be highlighted in search results */

        // Encrypt with constant timing
        byte[] result = cipher.doFinal(paddedMessage, 0, message.length);

        // Clear padded data
        java.util.Arrays.fill(paddedMessage, (byte) 0);

        return result;
    }

    /**
     * Constant-time array copy to prevent timing attacks
     */
    private void constantTimeCopy(byte[] src, int srcPos, byte[] dest, int destPos, int length) {

        result = NtlmMessage.readSecurityBuffer(data, 0);
        assertEquals(0, result.length, "Should return empty array for zero length buffer.");

        // Test with offset pointing to end of array (should result in empty array if length is 0)
        buffer.putShort(0, (short) 0);
        buffer.putShort(2, (short) 0);
        buffer.putInt(4, data.length);

                  related_query:
                    type: array
                    items:
                      type: string
                    example: ["aaa"]
                  related_contents:
                    type: array
                    items:
                      type: string
                    example: []
                  data:
                    type: array
                    items:

     *
     * @param src the source data array
     * @param soff the offset in the source array
     * @param slen the length of data to process
     * @param dst the destination array for the result
     * @param doff the offset in the destination array
     */
    public void update(final byte[] src, int soff, final int slen, final byte[] dst, int doff) {

                final SID[] resolved = list.toArray(new SID[list.size()]);
                resolveSids0(authorityServerName, tc, resolved);
                for (si = 0; si < resolved.length; si++) {
                    this.sidCache.put(resolved[si], resolved[si]);
                }
            }
        }
    }

    /**
     * Resolve an array of SIDs using a cache and at most one MSRPC request.
     * <p>

                resultDocIdsCache.put(queryId, docIdList.toArray(new String[docIdList.size()]));
            }
        });
    }

    /**
     * Retrieves the document IDs associated with a specific query ID.
     * Used for tracking which documents were displayed for a particular search query.
     *
     * @param queryId the unique identifier for the search query
     * @return an array of document IDs, or an empty array if not found

    }
  }

  /**
   * @return an array of the proper size with {@code null} as the key of the middle element.
   */
  protected Entry<K, V>[] createArrayWithNullKey() {
    Entry<K, V>[] array = createSamplesArray();
    int nullKeyLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullKeyLocation];
    array[nullKeyLocation] = entry(null, oldEntry.getValue());
    return array;
  }

  protected V getValueForNullKey() {

    resetContainer();
  }

  /**
   * @return an array of the proper size with {@code null} inserted into the middle element.
   */
  protected E[] createArrayWithNullElement() {
    E[] array = createSamplesArray();
    array[getNullLocation()] = null;
    return array;
  }

  protected void initCollectionWithNullElement() {
    E[] array = createArrayWithNullElement();