import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Change Notify request message.
 *
 * This command is used to monitor a directory for changes
 * and receive notifications when modifications occur.
 *
 * @author mbechler
 */
public class Smb2ChangeNotifyRequest extends ServerMessageBlock2Request<Smb2ChangeNotifyResponse> {

    /**
     * Flag to watch the directory tree recursively
     */

    // If we clip the safe range used during the per-character tests so it is
    // below the values of characters in surrogate pairs, this cannot occur.
    // This approach does mean that we break out of the fast path code in cases
    // where we don't strictly need to, but this situation will almost never
    // occur in practice.
    if (safeMin >= Character.MIN_HIGH_SURROGATE) {

 */

package com.google.common.eventbus;

import java.util.concurrent.Executor;

/**
 * An {@link EventBus} that takes the Executor of your choice and uses it to dispatch events,
 * allowing dispatch to occur asynchronously.
 *
 * @author Cliff Biffle
 * @since 10.0
 */
public class AsyncEventBus extends EventBus {

  /**
   * Creates a new AsyncEventBus that will use {@code executor} to dispatch events. Assigns {@code

   * mutated by the call thread only. If is accessed by background connect threads.
   */
  private val tcpConnectsInFlight = CopyOnWriteArrayList<Plan>()

  /**
   * Results are posted here as they occur. The find job is done when either one plan completes
   * successfully or all plans fail.
   */
  private val connectResults = taskRunner.backend.decorate(LinkedBlockingDeque<ConnectResult>())

/**
 * An abstract {@code ExecutorService} that allows subclasses to {@linkplain #wrapTask(Callable)
 * wrap} tasks before they are submitted to the underlying executor.
 *
 * <p>Note that task wrapping may occur even if the task is never executed.
 *
 * <p>For delegation without task-wrapping, see {@link ForwardingExecutorService}.
 *
 * @author Chris Nokleberg
 */
@J2ktIncompatible
@GwtIncompatible

/**
 * An abstract {@code ScheduledExecutorService} that allows subclasses to {@linkplain
 * #wrapTask(Callable) wrap} tasks before they are submitted to the underlying executor.
 *
 * <p>Note that task wrapping may occur even if the task is never executed.
 *
 * @author Luke Sandberg
 */
@J2ktIncompatible
@GwtIncompatible
abstract class WrappingScheduledExecutorService extends WrappingExecutorService

            final QueryBuilder queryBuilder = getQueryProcessor().execute(context, clause.query(), boost);
            if (queryBuilder != null) {
                switch (clause.occur()) {
                case MUST:
                    boolQuery.must(queryBuilder);
                    break;
                case SHOULD:
                    boolQuery.should(queryBuilder);
                    break;

/**
 * [HTTP/2][Protocol.HTTP_2] only. Processes server-initiated HTTP requests on the client.
 * Implementations must quickly dispatch callbacks to avoid creating a bottleneck.
 *
 * While [onReset] may occur at any time, the following callbacks are expected in order,
 * correlated by stream ID.
 *
 *  * [onRequest]
 *  * [onHeaders] (unless canceled)
 *  * [onData] (optional sequence of data frames)
 *

     * State#STARTING STARTING}. This occurs when {@link Service#startAsync} is called the first
     * time.
     */
    public void starting() {}

    /**
     * Called when the service transitions from {@linkplain State#STARTING STARTING} to {@linkplain
     * State#RUNNING RUNNING}. This occurs when a service has successfully started.
     */
    public void running() {}

    }

    /**
     * Safely add integers checking for overflow
     *
     * @param a first value
     * @param b second value
     * @return sum
     * @throws SmbException if overflow would occur
     */
    public int safeAdd(int a, int b) throws SmbException {
        totalValidations.incrementAndGet();

        long result = (long) a + (long) b;