Map<String, String> binding = new HashMap<>();
        binding.put(ScriptBindingParameter.APP_NAME.getKey(), details.getApplicationName());
        binding.put(ScriptBindingParameter.OPTS_ENV_VAR.getKey(), details.getOptsEnvironmentVar());
        binding.put(ScriptBindingParameter.EXIT_ENV_VAR.getKey(), details.getExitEnvironmentVar());

/**
 * An implementation of the Codec protocol that (based on a [Binding.tag]) chooses and delegates
 * to the proper binding (if one is found).
 *
 * The binding (a tagged codec) is chosen based on the availability of a [Binding.encoding] for the value being encoded.
 * This is basically implemented as a predicate dispatching on the value type, first available Binding.encoding wins

import kotlin.reflect.KFunction


interface DeclarativeRuntimeFunction {
    fun callBy(receiver: Any, binding: Map<DataParameter, Any?>, hasLambda: Boolean): InvocationResult

    fun callByWithErrorHandling(receiver: Any, binding: Map<DataParameter, Any?>, hasLambda: Boolean): InvocationResult {
        try {
            return callBy(receiver, binding, hasLambda)
        } catch (ite: InvocationTargetException) {
            throw ite.cause ?: ite

<% if (binding.hasVariable("buildScanPluginVersion") || binding.hasVariable("springDmPluginVersion")) {%>

buildscript {
    repositories {
<% if(binding.hasVariable("springDmPluginVersion")) { %>
        mavenLocal()
        mavenCentral()
<% } %>
<% if (binding.hasVariable("buildScanPluginVersion")) { %>
        maven {
            url 'https://repo.gradle.org/gradle/enterprise-libs-snapshots-local/'
        }
<% } %>
    }

	binding := obj.(*admissionregistration.ValidatingAdmissionPolicyBinding)
	if binding.Spec.ParamRef == nil {
		// no paramRef in new object
		return nil
	}

	return v.authorize(ctx, binding)
}

func (v *validatingAdmissionPolicyBindingStrategy) authorizeUpdate(ctx context.Context, obj, old runtime.Object) error {
	binding := obj.(*admissionregistration.ValidatingAdmissionPolicyBinding)

 * limitations under the License.
 */

<% if (binding.hasVariable("buildScanPluginVersion") || binding.hasVariable("springDmPluginVersion")) {%>

buildscript {
    repositories {
<% if(binding.hasVariable("springDmPluginVersion")) { %>
        mavenLocal()
        mavenCentral()
<% } %>
<% if (binding.hasVariable("buildScanPluginVersion")) { %>
        maven {

        for (ModelBinding binding : ruleBinder.getInputBindings()) {
            addRule(ruleBinder, rulesByInput, binding);
        }
    }

    private void addRule(RuleBinder rule, NodeAtStateIndex index, ModelBinding binding) {
        Reference reference = new Reference(rule, index, binding);
        BindingPredicate predicate = binding.getPredicate();
        if (predicate.getPath() != null) {

func (m *ValidatingAdmissionPolicyMetrics) ObserveAdmissionWithError(ctx context.Context, elapsed time.Duration, policy, binding, state string) {
	m.policyCheck.WithContext(ctx).WithLabelValues(policy, binding, "allow", state).Inc()
	m.policyLatency.WithContext(ctx).WithLabelValues(policy, binding, "allow", state).Observe(elapsed.Seconds())
}

	Resource schema.GroupVersionResource

	// Relevant binding for this hook.
	// May be empty if there was an error with the policy's configuration itself
	Binding B

	// Compiled policy evaluator
	Evaluator E

	// Params fetched by the binding to use to evaluate the policy
	Param runtime.Object

	// Error is set if there was an error with the policy or binding or its
	// params, etc
	Error error
}

                Set<Binding<Q>> res = getBindings(key);
                if (res != null && !res.isEmpty()) {
                    List<Binding<Q>> bindingList = new ArrayList<>(res);
                    Comparator<Binding<Q>> comparing = Comparator.comparing(Binding::getPriority);
                    bindingList.sort(comparing.reversed());
                    Binding<Q> binding = bindingList.get(0);