} while (r != start);

        if (res != null) {
            return res;
        }

        return dr;
    }

    /**
     * @param domains
     */
    private static void dumpReferralCache(final Map<String, Map<String, CacheEntry<DfsReferralDataInternal>>> domains) {
        for (final Entry<String, Map<String, CacheEntry<DfsReferralDataInternal>>> entry : domains.entrySet()) {

     * @param type
     *            the type to analyze
     * @param map
     *            the map to which the type variables and type arguments are added
     */
    protected static void gatherTypeVariables(final Class<?> clazz, final Type type, final Map<TypeVariable<?>, Type> map) {
        if (clazz == null) {
            return;
        }
        gatherTypeVariables(type, map);

  /**
   * The freshness level at which the {@link Empty @Empty} annotated method was invoked to generate
   * instance.
   */
  private final Map<Type, Integer> emptyInstanceGenerated = new HashMap<>();

  final <T> void addSampleInstances(Class<T> type, Iterable<? extends T> instances) {
    sampleInstances.putAll(checkNotNull(type), checkNotNull(instances));
  }

  /**

   * efficient than iterating over the {@link #entrySet()} either explicitly or with {@code
   * entrySet().forEach(action)}.
   *
   * @since 21.0
   */
  default void forEachEntry(ObjIntConsumer<? super E> action) {
    checkNotNull(action);
    entrySet().forEach(entry -> action.accept(entry.getElement(), entry.getCount()));
  }

  // Comparison and hashing

  /**

Vous pouvez donc l'utilisez comme tel :

{* ../../docs_src/path_params/tutorial004.py hl[6] *}

/// tip | Astuce

Vous pourriez avoir besoin que le paramètre contienne `/home/johndoe/myfile.txt`, avec un slash au début (`/`).

Dans ce cas, l'URL serait : `/files//home/johndoe/myfile.txt`, avec un double slash (`//`) entre `files` et `home`.

///

                    .collect(Collectors.toList()); // sorted and filtered to what we need
        } else {
            return Collections.singletonList(project);
        }
    }

    public void resolveProjectDependencies(
            MavenProject project,
            Collection<String> scopesToCollect,
            Collection<String> scopesToResolve,
            MavenSession session,

    int i = 0;
    for (Object element : elements) {
      array[i++] = element;
    }
    return array;
  }

  /** Swaps {@code array[i]} with {@code array[j]}. */
  static void swap(Object[] array, int i, int j) {
    Object temp = array[i];
    array[i] = array[j];
    array[j] = temp;
  }

  @CanIgnoreReturnValue
  static Object[] checkElementsNotNull(Object... array) {

   * #entrySet}. If you override {@link #entrySet}, you may wish to override {@link #clear} to
   * forward to this implementation.
   *
   * @since 7.0
   */
  @Override
  protected void standardClear() {
    Iterators.clear(entrySet().iterator());
  }

  /**
   * A sensible, albeit inefficient, definition of {@link #count} in terms of {@link #entrySet}. If

                if (match) {
                    dr = (DfsReferral) referrals.map.get(_key);
                }
            }
        }

        return dr;
    }

    synchronized void insert(final String path, final DfsReferral dr) {
        int s1, s2;
        String server, share, key;

        if (DISABLED) {
            return;
        }

        s1 = path.indexOf('\\', 1);

Et c'est le même niveau de performance que celui obtenu avec **FastAPI**.