final UnmodifiableIterator<E> iterator = iterator();

      @Override
      public boolean tryAdvance(Consumer<? super E> action) {
        if (iterator.hasNext()) {
          action.accept(iterator.next());
          return true;
        } else {
          return false;
        }
      }

      @Override
      public Comparator<? super E> getComparator() {
        return comparator;

@app.websocket("/function-scope")
async def function_scope(websocket: WebSocket, session: SessionFuncDep) -> Any:
    await websocket.accept()
    await websocket.send_json({"is_open": session.open})


@app.websocket("/request-scope")
async def request_scope(websocket: WebSocket, session: SessionRequestDep) -> Any:
    await websocket.accept()
    await websocket.send_json({"is_open": session.open})


@app.websocket("/two-scopes")

        innerClassNode.access &= ~ACC_PRIVATE;
        innerClassNode.access |= ACC_PUBLIC;
    }

    private void writeClass(String classFile, ClassNode classNode) throws IOException {
        ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
        classNode.accept(classWriter);

        File outputFile = outputDir.get().file(classFile).getAsFile();

 *
 * <p>Note that this implementation is not synchronized. If multiple threads access the same cell of
 * an {@code ArrayTable} concurrently and one of the threads modifies its value, there is no
 * guarantee that the new value will be fully visible to the other threads. To guarantee that
 * modifications are visible, synchronize access to the table. Unlike other {@code Table}

   * comes up in practice (maybe through some kind of sanitizer-like testing that intentionally
   * inflicts spurious interrupts on us?), we might have to accept some flakiness or disable some
   * tests, at least under whichever environment (JRE or Android) we see such problems.
   */

  @SuppressWarnings("WaitNotInLoop") // see comment above

        } else {
          assertTrue(desc, isGuarded(method));
        }
        // we can't make an assumption about isTimed() because now we have single-parameter methods
        // that accept a java.time.Duration
        assertFalse(desc, isLongTimeUnitBased(method));
        break;
      case 2:
        if (isDurationBased(method)) {
          assertTrue(desc, isGuarded(method));
        } else {

   *
   * <p><b>Note:</b> the utility method {@link Iterables#frequency} generalizes this operation; it
   * correctly delegates to this method when dealing with a multiset, but it can also accept any
   * other iterable type.
   *
   * @param element the element to count occurrences of
   * @return the number of occurrences of the element in this multiset; possibly zero but never
   *     negative
   */

        writer.accept("=== PROJECT BUILD PLAN ================================================");
        writer.accept("Project:                     " + getKey(project));
        writer.accept("Repositories (dependencies): " + project.getRemoteProjectRepositories());
        writer.accept("Repositories (plugins):      " + project.getRemotePluginRepositories());

convertDistributionU(java.io.File, String); } org/gradle/wrapper/BootstrapMainStarter$1.class package org.gradle.wrapper; public final class BootstrapMainStarter$1 implements java.io.FilenameFilter { public void BootstrapMainStarter$1(); public final boolean accept(java.io.File, String); } org/gradle/wrapper/Download$DefaultDownloadProgr.class package org.gradle.wrapper; public final class Download$DefaultDownloadProgr { public final Logger logger; public final Download$DefaultDownloadProgr delegate; public...

     * An interface for consuming search results.
     */
    interface SearchConsumer {
        /**
         * Accepts a list of search results.
         *
         * @param t The list of search results.
         * @throws NamingException If a naming exception occurs.
         */
        void accept(List<SearchResult> t) throws NamingException;
    }

    /**
     * Gets the directory context.
     *