* @param type the type to project the node as
     * @param <T> the type to project the node as
     * @return the node as the given type
     */
    <T> T realize(ModelPath path, ModelType<T> type);
    <T> T realize(String path, ModelType<T> type);
    <T> T realize(String path, Class<T> type);

    /**
     * Get the fully defined model element at the given path.
     * <p>

    }

    public static Object realize(ModelRegistry modelRegistry, String path) {
        return modelRegistry.realize(ModelPath.nonNullValidatedPath(path), ModelType.UNTYPED);
    }

    public static <T> T realize(ModelRegistry modelRegistry, String path, Class<T> type) {
        return modelRegistry.realize(ModelPath.nonNullValidatedPath(path), ModelType.of(type));
    }

package org.gradle.api.internal.collections;

import javax.annotation.Nullable;

/**
 * Tracks which types are subscribed to by eager event listeners. Lazy elements of a
 * subscribed type should be immediately realized when added to a container.
 */
public interface EventSubscriptionVerifier<T> {

    /**
     * Determines whether events should be emitted for elements of the given type.
     */

        try {
            List<String> mergeCommitFileLines = showFileOnCommit(mergeCommit, filePath).readLines()
            List<String> masterCommitFileLines = showFileOnCommit(masterCommit, filePath).readLines()
            List<String> releaseCommitFileLines = showFileOnCommit(releaseCommit, filePath).readLines()
            for (String line in mergeCommitFileLines) {
                if (line.trim().isEmpty()) {

            }
            realizedRepositories.add(realize(repository));
        }
    }

    private RealizedJavaToolchainRepository realize(JavaToolchainRepository repository) {
        Class<? extends JavaToolchainResolver> repositoryClass = getResolverClass(repository);

    /**
     * Adds an action to be executed when a value from a pending element is concretely added.
     * The provided action is only called when a pending value is realized and the value is not
     * already present in the concrete values of this source.
     */
    void onPendingAdded(Action<T> action);

    boolean isEmpty();

    int size();

    void clear();

        assert removeDownloadMessageAndEmptyLines(actualOutput) == expected(expectedOutput)
        return true
    }

    String removeDownloadMessageAndEmptyLines(String output) {
        return output.readLines().findAll { !it.isEmpty() && !(it ==~ /^Download http.*$/) }.join('\n')
    }

    String expected(String normalised) {
        String raw = """------------------------------------------------------------
Root project 'test'

        return process.inputStream.readLines().drop(3).collect { new File(it).name }
    }

    List<String> listLinkedLibraries() {
        def dumpbin = findExe("dumpbin.exe")
        def process = [dumpbin.absolutePath, '/IMPORTS', binaryFile.absolutePath].execute(["PATH=$vcPath"], null)
        return process.inputStream.readLines()
    }

    List<BinaryInfo.Symbol> listSymbols() {

        def reversedFile = workerExecutorSample(dsl).file("build/reversed/${author}.txt")
        assert reversedFile.exists()
        assert reversedFile.readLines() == workerExecutorSample(dsl).file("sources/${author}.txt").readLines().collect { it.reverse() }
    }

   */
  @CanIgnoreReturnValue // some processors won't return a useful result
  @ParametricNullness
  public static <T extends @Nullable Object> T readLines(
      URL url, Charset charset, LineProcessor<T> callback) throws IOException {
    return asCharSource(url, charset).readLines(callback);
  }

  /**
   * Reads all of the lines from a URL. The lines do not include line-termination characters, but do