return logLevel;
    }

    public boolean isFailed() {
        return workerProcess.getExecResult().map(execResult -> execResult.getExitValue() != 0).orElse(false);
    }

    public Optional<Integer> getExitCode() {
        return workerProcess.getExecResult().map(ExecResult::getExitValue);
    }

    public boolean isNotExpirable() {
        return cannotBeExpired;
    }

    @Override

    String javaPluginToolchainVersion(JvmInstallationMetadata installationMetadata) {
        return javaPluginToolchainVersion(installationMetadata.languageVersion.majorVersionNumber)
    }

    String javaPluginToolchainVersion(Integer majorVersion) {
        """
            java {
                toolchain {
                    languageVersion = JavaLanguageVersion.of(${majorVersion})
                }
            }
        """
    }

    static JavaLanguageVersion of(int version) {
        return DefaultJavaLanguageVersion.of(version);
    }

    static JavaLanguageVersion of(String version) {
        return of(Integer.parseInt(version));
    }

    /**
     * Get the current (i.e., the current runtime) Java Language version.
     *
     * @return the current Java Language version
     * @since 8.8
     */
    @Incubating

//go:build unix || (js && wasm) || wasip1

package syscall

import (
	"internal/byteorder"
	"internal/goarch"
	"runtime"
	"unsafe"
)

// readInt returns the size-bytes unsigned integer in native byte order at offset off.
func readInt(b []byte, off, size uintptr) (u uint64, ok bool) {
	if len(b) < int(off+size) {
		return 0, false
	}
	if goarch.BigEndian {
		return readIntBE(b[off:], size), true
	}

	if err != nil {
		return true
	}
	if atLeast {
		return cv.AtLeast(ev)
	}
	return cv.LessThan(ev)
}

// GetVersionAsInt returns the the kubernetes version as an integer.
// For example, on Kubernetes v1.15.2, GetVersionAsInt returns 115
func GetVersionAsInt(client Client) int {
	clusterVersion, err := client.GetKubernetesVersion()
	if err != nil {
		return -1
	}

        Matcher matcher = pattern.matcher(daemonLog.text);
        assert matcher.matches(): "Unable to find daemon address in the daemon log. Daemon: $context"

        try {
            return Integer.parseInt(matcher.group(1))
        } catch (NumberFormatException e) {
            throw new RuntimeException("Unexpected format of the port number found in the daemon log. Daemon: $context")
        }
    }

                }
            }

            interface TargetColor extends TransformParameters {
                @Input
                Property<String> getTargetColor()
                @Input
                Property<Integer> getMultiplier()
            }

            abstract class MakeColor implements TransformAction<TargetColor> {
                @InputArtifact
                abstract Provider<FileSystemLocation> getInputArtifact()

#include "mlir/Support/LLVM.h"  // from @llvm-project

namespace mlir {
namespace TF {

// Returns int, float or complex DenseElementsAttr with scalar shape with the
// given element type and the integer value.
template <typename T>
DenseElementsAttr GetScalarOfType(Type ty, T raw_value) {
  RankedTensorType scalar_ty = RankedTensorType::get({}, ty);
  if (auto float_ty = mlir::dyn_cast<FloatType>(ty)) {

    private final List<OutputEvent> queue = new ArrayList<OutputEvent>();

    public ThrottlingOutputEventListener(OutputEventListener listener, Clock clock) {
        this(listener, Integer.getInteger("org.gradle.internal.console.throttle", 100), Executors.newSingleThreadScheduledExecutor(), clock);
    }

// FromString creates an IntOrString object with a string value.
func FromString(val string) IntOrString {
	return IntOrString{Type: String, StrVal: val}
}

// Parse the given string and try to convert it to an int32 integer before
// setting it as a string value.
func Parse(val string) IntOrString {
	i, err := strconv.ParseInt(val, 10, 32)
	if err != nil {
		return FromString(val)
	}
	return FromInt32(int32(i))
}