Registries current = registries.get();
        Registries next = current.startProjectExecution(parallel);
        setProjectExecutionState(current, next);
    }

    @Override
    public void finishProjectExecution() {
        // TODO - check no locks are currently held
        Registries current = registries.get();
        Registries next = current.finishProjectExecution();

        String current = getVersion();
        if (current.equals(version) || (version == null && current.isEmpty())) {
            return this;
        }
        return new RelocatedArtifact(artifact, groupId, artifactId, classifier, extension, version, message);
    }

    @Deprecated
    @Override
    public Artifact setFile(File file) {
        File current = getFile();

    }

    static void assumeCurrentJavaVersionIsSupportedBy(VersionNumber kotlinVersionNumber) {
        JavaVersion current = JavaVersion.current()
        JavaVersion mini = getMinimumJavaVersionFor(kotlinVersionNumber)
        assumeTrue("KGP $kotlinVersionNumber minimum supported Java version is $mini, current is $current", current >= mini)
        JavaVersion maxi = getMaximumJavaVersionFor(kotlinVersionNumber)
        if (maxi != null) {

     * @throws IllegalStateException if the passed entry point token does not match the current innermost instrumented call tracked for the thread.
     */
    void leaveCall(EntryPointCallSite entryPoint);

    /**
     * Checks if the current thread's innermost instrumented call matches the name and call kind, and has not been marked as intercepted yet.
     *

        BinaryInfo info
        if (OperatingSystem.current().isWindows() && !DumpbinBinaryInfo.findVisualStudio()) {
            info = new FileArchOnlyBinaryInfo(file)
        } else {
            info = getBinaryInfo()
        }
        return info.getArch()
    }

    BinaryInfo getBinaryInfo() {
        file.assertExists()
        if (OperatingSystem.current().isMacOsX()) {

        CtClass current = c
        while (current != null) {
            if (containsMethod(current, method)) {
                classesContainingMethod.add(current)
            } else {
                break
            }
            current = current.getSuperclass()
        }

        for (int i = classesContainingMethod.size() - 1; i > 0; --i) {
            current = classesContainingMethod.get(i)

	Modified map[string]interface{}
	// Current is the current object (live config in the server)
	Current map[string]interface{}
	// TwoWay is the expected two-way merge patch diff between original and modified
	TwoWay map[string]interface{}
	// ThreeWay is the expected three-way merge patch
	ThreeWay map[string]interface{}
	// Result is the expected object after applying the three-way patch on current object.
	Result map[string]interface{}

}

// ObjectMetricStatus indicates the current value of a metric describing a
// kubernetes object (for example, hits-per-second on an Ingress object).
type ObjectMetricStatus struct {
	Metric  MetricIdentifier
	Current MetricValueStatus

	DescribedObject CrossVersionObjectReference
}

// PodsMetricStatus indicates the current value of a metric describing each pod in

  val i = mappings.iterator()
  var current = i.next()

  while (true) {
    if (current.spansSections) {
      result +=
        Mapping(
          current.sourceCodePoint0,
          current.section + 0x7f,
          current.type,
          current.mappedTo,
        )
      current =
        Mapping(
          current.section + 0x80,
          current.sourceCodePoint1,
          current.type,

    private static final GradleVersionSpec GRADLE_VERSION_SPEC = new GradleVersionSpec()

    static {
        // If we are testing a non-current tooling API version, we will have loaded the class using its classloader and thus
        // GradleVersion.current() will report that version. In order to set up the testing infrastructure, we need to
        // know the version of Gradle being built