* String.class}, then {@code new TypeResolver().where(formal, actual)} will {@linkplain
   * #resolveType resolve} {@code ParameterizedType List<T>} to {@code List<String>}, and resolve
   * {@code Map<T, Something>} to {@code Map<String, Something>} etc. Similarly, {@code formal} and
   * {@code actual} can be {@code Map<K, V>} and {@code Map<String, Integer>} respectively, or they

     *
     * @return {@code true} if remote access has been disabled, {@code false} otherwise.
     */
    @Override
    boolean isOffline();

    /**
     * Enables/disables network access to remote repositories.
     *
     * @param offline {@code true} to disable remote access, {@code false} to allow network access.
     * @return This request, never {@code null}.
     */
    @Override

   *     been added to the filter. Note that {@code put(t)} always returns the <i>opposite</i>
   *     result to what {@code mightContain(t)} would have returned at the time it is called.
   * @since 12.0 (present in 11.0 with {@code void} return type})
   */
  @CanIgnoreReturnValue
  public boolean put(@ParametricNullness T object) {
    return strategy.put(object, funnel, numHashFunctions, bits);

 * of <code>0x001200A9</code> which doesn't have the
 * <code>FILE_WRITE_DATA</code> bit on (bit <code>0x00000002</code>). Actually, this isn't quite correct. If
 * <code>WNET\alice</code> is in the local <code>Administrators</code> group the access check
 * will succeed because the inherited ACE allows local <code>Administrators</code>
 * both <code>FILE_READ_DATA</code> and <code>FILE_WRITE_DATA</code> access.
 *
 */

   * execute/submit/schedule}, as in {@link CallerRunsPolicy}. This applies both to individually
   * submitted tasks and to collections of tasks submitted via {@code invokeAll}, {@code invokeAny},
   * {@code schedule}, {@code scheduleAtFixedRate}, and {@code scheduleWithFixedDelay}. In the case
   * of tasks submitted by {@code invokeAll} or {@code invokeAny}, tasks will run serially on the

        }
    }

    /**
     * Creates and returns an initial context using the specified environment.
     *
     * @param env
     *            The environment used to create the initial context. <code>null</code> indicates an empty environment.
     * @return The initial context
     */
    public static InitialContext create(final Hashtable<?, ?> env) {
        try {
            return new InitialContext(env);

    resetContainer(getSubjectGenerator().create(array));
  }

  /**
   * Equivalent to {@link #expectMissing(Object[]) expectMissing}{@code (null)} except that the call
   * to {@code contains(null)} is permitted to throw a {@code NullPointerException}.
   *
   * @param message message to use upon assertion failure
   */
  protected void expectNullMissingWhenNullUnsupported(String message) {
    try {

     */
    @Nonnull
    DependencyScope getScope();

    /**
     * Returns whether the dependency is optional, mandatory, or of unspecified obligation.
     *
     * @return {@code Boolean.TRUE} and {@code Boolean.FALSE} if optional, or {@code null} if unspecified
     */
    @Nullable
    Boolean getOptional();

    /**
     * {@return transitive dependencies to exclude}
     */
    @Nonnull

     * <groupId>:<artifactId>:<version>} but some of these coordinates may still be unknown at the point the exception
     * is thrown so this information is merely meant to assist the user.
     *
     * @return the identifier of the project or an empty string if not known, never {@code null}
     */
    @Nonnull
    String getProjectId();

    /**

  /**
   * Returns {@code x}, rounded to a {@code double} with the specified rounding mode. If {@code x}
   * is precisely representable as a {@code double}, its {@code double} value will be returned;
   * otherwise, the rounding will choose between the two nearest representable values with {@code
   * mode}.
   *
   * <p>For the case of {@link RoundingMode#HALF_DOWN}, {@code HALF_UP}, and {@code HALF_EVEN},