import org.gradle.nativeplatform.toolchain.internal.ToolType;

import javax.annotation.Nullable;

@NonNullApi
public interface ToolRegistry {
    @Nullable
    GccCommandLineToolConfigurationInternal getTool(ToolType toolType);

    }

    private static class FilteredTree {
        private final String root;
        private final PatternSet patterns;

        private FilteredTree(String root, PatternSet patterns) {
            this.root = root;
            this.patterns = patterns;
        }

        public String getRoot() {
            return root;
        }

        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Internal abstract ConfigurableFileCollection getFoo()
                @Internal abstract ConfigurableFileCollection getBar()
                @Inject abstract ProjectLayout getLayout()

                @TaskAction
                void useIt() {

			msg := fmt.Sprintf("rejected due to timeout after waiting %v at plugin %v",
				waitTime, plugin)
			wp.Reject(plugin, msg)
		})
	}

	return wp
}

// GetPod returns a reference to the waiting pod.
func (w *waitingPod) GetPod() *v1.Pod {
	return w.pod
}

// GetPendingPlugins returns a list of pending permit plugin's name.
func (w *waitingPod) GetPendingPlugins() []string {
	w.mu.RLock()

fun test(b: Boolean) {
    <expr>object {
        fun getBool(): Boolean = b
    }</expr>

    }

    private Path getPath(String name, Level level) {
        return directoryProvider.getRoot(level).resolve(name);
    }

    @Override
    public DataTargetFactory createTargetFactory(final String root, Level level) throws IOException {
        final Path rootDir = Files.createTempDirectory(directoryProvider.getRoot(level), root);
        return new DataTargetFactory() {
            @Override

package org.gradle.platform.base.internal.dependents;

/**
 * Holds the result of a dependent binaries resolution.
 */
public interface DependentBinariesResolutionResult {

    DependentBinariesResolvedResult getRoot();

            outstr.writeLong(index.rootPos.getPos());
            outstr.writeShort(maxChildIndexEntries);
        }

        public IndexBlock getRoot() throws Exception {
            return index.getRoot();
        }
    }

    private class IndexBlock extends BlockPayload {
        private final List<IndexEntry> entries = new ArrayList<IndexEntry>();

	sort.Strings(wait)
	msg := fmt.Sprintf(`Processing resources for %s.`, strings.Join(comps, ", "))
	if len(wait) > 0 {
		msg += fmt.Sprintf(` Waiting for %s`, strings.Join(wait, ", "))
	}
	prefix := inProgress
	if !p.bar.GetBool(pb.Terminal) {
		// If we aren't a terminal, no need to spam extra lines
		prefix = `{{ yellow "-" }} `
	}
	// reduce by 2 to allow for the "- " that will be added below
	maxWidth -= 2

 * limitations under the License.
 */

package org.gradle.caching.internal.tasks;

import org.openjdk.jmh.annotations.Level;

import java.nio.file.Path;

public interface DirectoryProvider {
    Path getRoot(Level level);