for (O option : options) {
            Optional<T> o = getter.apply(option);
            if (o.isPresent()) {
                return o;
            }
        }
        return Optional.empty();
    }

    protected Optional<List<String>> collectListIfPresentOrEmpty(Function<O, Optional<List<String>>> getter) {
        int had = 0;

  volatile @Nullable Waiter waitersField;

  /** Non-volatile write of the thread to the {@link Waiter#thread} field. */
  private static void putThread(Waiter waiter, Thread newValue) {
    ATOMIC_HELPER.putThread(waiter, newValue);
  }

  /** Non-volatile write of the waiter to the {@link Waiter#next} field. */
  private static void putNext(Waiter waiter, @Nullable Waiter newValue) {

                    writer.println("<h3>In $project</h3>")
                    writer.println("<ul>")
                    problems.forEach {
                        writer.println("   <li>${it.name.escape()}</li>")
                    }
                    writer.println("</ul>")
                }
            }
            writer.println("</body></html>")
        }
    }

    private

            throws ModelInterpolationException {
        StringWriter sWriter = new StringWriter(1024);

        MavenStaxWriter writer = new MavenStaxWriter();
        try {
            writer.write(sWriter, model.getDelegate());
        } catch (IOException | XMLStreamException e) {

  public void setUp() {
    sink = new TestCharSink();
  }

  public void testOpenBufferedStream() throws IOException {
    Writer writer = sink.openBufferedStream();
    assertTrue(sink.wasStreamOpened());
    assertFalse(sink.wasStreamClosed());

    writer.write(STRING);
    writer.close();

    assertTrue(sink.wasStreamClosed());
    assertEquals(STRING, sink.getString());
  }

import java.io.OutputStreamWriter;
import java.io.Writer;

import org.codelibs.core.exception.IORuntimeException;

/**
 * Utility class for {@link Writer} operations.
 *
 * @author koichik
 */
public abstract class WriterUtil {

    /**
     * Do not instantiate.
     */
    protected WriterUtil() {
    }

    /**
     * Creates a {@link Writer} to output to a stream with the specified encoding.
     *

    }

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param persistedToolchains a persistedToolchains object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, PersistedToolchains persistedToolchains) throws IOException {
        try {
            delegate.write(writer, persistedToolchains.getDelegate());

        if (!context.interactive) {
            context.terminal.writer().println("This tool works only in interactive mode!");
            context.terminal
                    .writer()
                    .println("Tool purpose is to configure password management on developer workstations.");
            context.terminal
                    .writer()
                    .println(

                try {
                    writer.write(s);
                    writer.write('\n');
                } catch (final IOException e) {
                    throw new IORuntimeException(e);
                }
            });
        } catch (final Exception e) {
            logger.warn("Failed to write thread dump: file={}", file, e);
        }
    }

    /**

// implementation which is buggy on NUMA systems, we have to use a simpler
// io.Writer implementation alone avoids also unnecessary buffer copies,
// and as such incurred latencies.
var Discard io.Writer = discard{}

// discard is /dev/null for Golang.
type discard struct{}

func (discard) Write(p []byte) (int, error) {
	return len(p), nil
}

// DiscardReader discarded reader