int maxCount, minCount, remaining;

    /**
     * Constructs a Read AndX request.
     *
     * @param config the configuration
     */
    public SmbComReadAndX(final Configuration config) {
        super(config, SMB_COM_READ_ANDX);
        this.openTimeout = 0xFFFFFFFF;
    }

    /**
     * Constructs a Read AndX request with parameters.
     *
     * @param config the configuration

    //
    // p4 inherits from p3
    // p3 inherits from p2
    // p2 inherits from p1
    // p1 inherits from p0
    // p0 inherits from super model
    //
    // or we can show it graphically as:
    //
    // p4 ---> p3 ---> p2 ---> p1 ---> p0 --> super model
    //
    // ----------------------------------------------------------------------

    @Test

/**
 * Query command for match all documents query.
 */
public class MatchAllQueryCommand extends QueryCommand {

    /**
     * Default constructor.
     */
    public MatchAllQueryCommand() {
        super();
    }

    private static final Logger logger = LogManager.getLogger(MatchAllQueryCommand.class);

    @Override
    protected String getQueryClassName() {
        return MatchAllDocsQuery.class.getSimpleName();

        val inetSocketAddress = hostMapping[requested.address] ?: defaultAddress ?: requested
        Platform.get().log("Socket connection to: $inetSocketAddress was: $requested")
        super.connect(inetSocketAddress, timeout)
      }
    }

      checkNotNull(entry.getKey());
      checkNotNull(entry.getValue());
    }
    return new ImmutableEnumMap<K, V>(map);
  }

  private ImmutableEnumMap(Map<? extends K, ? extends V> delegate) {
    super(delegate);
  }

    /**
     * Creates a new request to close a SAM handle.
     *
     * @param handle the policy handle to close
     */
    public MsrpcSamrCloseHandle(final policy_handle handle) {
        super(handle);
        this.ptype = 0;
        this.flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

    /**
     * @param message the message for the exception
     * @param e the exception itself
     */
    public XmlWriterException(String message, Location location, Exception e) {
        super(message, e);
        this.location = location;
    }

    public Location getLocation() {
        return location;
    }

            indexName = super.asEsIndex().replaceFirst(Pattern.quote("fess_config"), name);
        }
        return indexName;
    }

    @Override
    public OptionalEntity<ScheduledJob> selectByPK(final String id) {
        Exception lastException = null;
        for (int i = 0; i < 30; i++) {
            try {
                return super.selectByPK(id);
            } catch (final Exception e) {

      Class<Throwable> exceptionType,
      Function<? super Throwable, ? extends V> fallback,
      Executor executor) {
    return AbstractCatchingFuture.create(input, exceptionType, fallback, executor);
  }

  public static <V extends @Nullable Object> ListenableFuture<V> catchingAsync(
      ListenableFuture<? extends V> input,
      Class<Throwable> exceptionType,
      AsyncFunction<? super Throwable, ? extends V> fallback,

    have prod supersource, even if they have none. GWT is happy to ignore us
    when we specify a nonexistent path.

    (I hope that this workaround does not cause its own problems in the future.)
-->
<super-source path="super"/>

<inherits name="com.google.common.annotations.Annotations" />
<inherits name="com.google.common.base.Base" />
<inherits name="com.google.common.collect.Collect" />