eventSource: EventSource,
    response: Response,
  ) {
  }

  /**
   * Invoked when a new event has been sent to the client.
   *
   * @param id The `id` line of the event, might be null.
   * @param type The `event` line of the event, might be null.
   * @param data The `data` line of the event.
   */
  open fun onEvent(
    eventSource: EventSource,
    id: String?,
    type: String?,
    data: String,
  ) {

    /** Flag indicating if the memory region is still valid */
    protected volatile boolean valid;

    /**
     * Create new RDMA memory region
     *
     * @param buffer memory buffer to register
     * @param access access permissions
     */
    public RdmaMemoryRegion(ByteBuffer buffer, EnumSet<RdmaAccess> access) {
        this.buffer = buffer;
        this.accessFlags = access;

    private static final long serialVersionUID = 1L;

    /**
     * Constructs a new CurlException with the specified detail message and cause.
     *
     * @param message the detail message (which is saved for later retrieval by the {@link #getMessage()} method).
     * @param cause the cause (which is saved for later retrieval by the {@link #getCause()} method).

    /**
     * Constructs an AvTargetName from raw byte data
     *
     * @param raw the raw byte data for the target name AV pair
     */
    public AvTargetName(final byte[] raw) {
        super(AvPair.MsvAvTargetName, raw);
    }

    /**
     * Constructs an AvTargetName with the specified target name
     *
     * @param targetName the target name string to encode
     */

        // Default constructor
    }

    /**
     * Parse Kerberos authorization data based on the authorization type.
     *
     * @param authType the type of authorization data
     * @param token the authorization data token
     * @param keys the Kerberos keys for decryption
     * @return a list of parsed authorization data
     * @throws PACDecodingException if the data cannot be decoded
     */

    /**
     * Constructs an AvTimestamp from raw byte data
     *
     * @param raw the raw byte data for the timestamp AV pair
     */
    public AvTimestamp(final byte[] raw) {
        super(AvPair.MsvAvTimestamp, raw);
    }

    /**
     * Constructs an AvTimestamp with the specified timestamp value
     *
     * @param ts the timestamp value in Windows FILETIME format
     */
    public AvTimestamp(final long ts) {

   * current count is not {@code oldCount}, no change is made.
   *
   * @param element the element to conditionally set the count of; may be null only if explicitly
   *     allowed by the implementation
   * @param oldCount the expected present count of the element in this multiset
   * @param newCount the desired count of the element in this multiset

    private String share; // Can be null

    private Address[] addresses;
    private int addressIndex;
    private int type;

    private final CIFSContext ctx;

    /**
     *
     * @param ctx
     * @param u
     */
    public SmbResourceLocatorImpl(final CIFSContext ctx, final URL u) {
        this.ctx = ctx;
        this.url = u;
    }

    /**
     * {@inheritDoc}
     *

  }

  private static @Nullable Object generateDummyArg(Parameter param, FreshValueGenerator generator)
      throws ParameterNotInstantiableException {
    if (isNullable(param)) {
      return null;
    }
    Object arg = generator.generateFresh(param.getType());
    if (arg == null) {
      throw new ParameterNotInstantiableException(param);
    }
    return arg;
  }

   *
   * @param values a series of values
   */
  public static Stats of(double... values) {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(values);
    return accumulator.snapshot();
  }

  /**
   * Returns statistics over a dataset containing the given values.
   *
   * @param values a series of values
   */