}

    public Throwable getException() {
        return exception;
    }

    public String getMessage() {
        return message;
    }

    public String getReference() {
        return reference;
    }

    public List<ExceptionSummary> getChildren() {
        return children;
    }

        }
        return unboundRules;
    }

    private UnboundRuleInput.Builder toInputBuilder(ModelBinding binding) {
        ModelReference<?> reference = binding.getPredicate().getReference();
        UnboundRuleInput.Builder builder = UnboundRuleInput.type(reference.getType());
        ModelPath path;
        if (binding.isBound()) {
            builder.bound();

            ModelPath path = node.getPath();
            throw new InvalidModelRuleException(referrer, new ModelRuleBindingException(
                new AmbiguousBindingReporter(predicate.getReference(), boundTo.getPath(), boundTo.getDescriptor(), path, creatorDescriptor).asString()
            ));
        }

        doOnBind(node);
    }

    protected void doOnBind(ModelNodeInternal node) {

	klog.V(3).InfoS("computePodActions got for pod", "podActions", podContainerChanges, "pod", klog.KObj(pod))
	if podContainerChanges.CreateSandbox {
		ref, err := ref.GetReference(legacyscheme.Scheme, pod)
		if err != nil {
			klog.ErrorS(err, "Couldn't make a ref to pod", "pod", klog.KObj(pod))
		}
		if podContainerChanges.SandboxID != "" {

====

====
include::sample[dir="snippets/ant/properties/groovy",files="build.xml[tags=setreference]"]
====

There are several ways to get an Ant reference:

====
include::sample[dir="snippets/ant/properties/groovy",files="build.xml[tags=getreference]"]
====

====
include::sample[dir="snippets/ant/properties/kotlin",files="build.gradle.kts[tags=get-reference]"]

        String referenceKey = "";

        if (summary.getReference() != null && !summary.getReference().isEmpty()) {
            referenceKey =
                    references.computeIfAbsent(summary.getReference(), k -> "[Help " + (references.size() + 1) + "]");
        }

        String msg = summary.getMessage();

}

func (f *FakeRecorder) generateEvent(obj runtime.Object, timestamp metav1.Time, eventtype, reason, message string) {
	f.Lock()
	defer f.Unlock()
	ctx := context.TODO()
	ref, err := ref.GetReference(legacyscheme.Scheme, obj)
	if err != nil {
		klog.FromContext(ctx).Error(err, "Encountered error while getting reference")
		return
	}
	event := f.makeEvent(ref, eventtype, reason, message)

    def ant() {
        given:
        Closure configureClosure = { fileset(dir: 'dir', id: 'fileset') }
        when:
        project.ant(configureClosure)
        then:
        project.ant.project.getReference('fileset') instanceof FileSet
    }

    def createAntBuilder() {
        expect:
        project.createAntBuilder().is(testAntBuilder)
    }

    def compareTo() {
        expect:

	recorder.Eventf(cj, corev1.EventTypeNormal, "SuccessfulDelete", "Deleted job %v", job.Name)

	return true
}

func getRef(object runtime.Object) (*corev1.ObjectReference, error) {
	return ref.GetReference(scheme.Scheme, object)
}

func formatSchedule(cj *batchv1.CronJob, recorder record.EventRecorder) string {
	if strings.Contains(cj.Spec.Schedule, "TZ") {
		if recorder != nil {

			Resources:   v1.VolumeResourceRequirements{Requests: v1.ResourceList{v1.ResourceName(v1.ResourceStorage): resource.MustParse("1Gi")}},
			VolumeMode:  &fs,
		},
	}
	claimRef, err := ref.GetReference(scheme.Scheme, claim)
	if err != nil {
		t.Errorf("error getting claimRef: %v", err)
	}

	pv1 := testVolume("pv1", "1Gi")
	pv5 := testVolume("pv5", "5Gi")
	pv8 := testVolume("pv8", "8Gi")