*newPodClaims = make(map[string]string)
	}
	(*newPodClaims)[podClaim.Name] = claim.Name

	return nil
}

// findPodResourceClaim looks for an existing ResourceClaim with the right
// annotation (ties it to the pod claim) and the right ownership (ties it to
// the pod).
func (ec *Controller) findPodResourceClaim(pod *v1.Pod, podClaim v1.PodResourceClaim) (*resourcev1alpha2.ResourceClaim, error) {

     * in either order: that is, if {@code left instanceof L && right instanceof R} or {@code left instanceof R && right instanceof L}.
     *
     * @param left an exclude spec
     * @param right another exclude spec
     * @return {@code true} if this intersection applies to the given exclude specs (in any order); {@code false} otherwise
     */
    boolean applies(ExcludeSpec left, ExcludeSpec right);

    /**

        protected final Collector<T> left;
        protected final Collector<T> right;

        private AbstractPlusCollector(Collector<T> left, Collector<T> right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public int size() {
            return left.size() + right.size();
        }

        @Override
        public ValueProducer getProducer() {

        def mergedSideEffect = Mock(ValueSupplier.SideEffect)

        def left = Providers.of("left").withSideEffect(leftSideEffect)
        def right = Providers.of("right").withSideEffect(rightSideEffect)

        def provider = new MergeProvider([left, right]).withSideEffect(mergedSideEffect)

        when:
        provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)

end box

ConsumerConnection -> ModelProducer: request
activate ModelProducer
ModelProducer -> DefaultConnection: request
note right
DefaultConnection has entry points to accept calls from different ToolingAPI versions
end note
DefaultConnection -> ProviderConnection: request
note right
request is funneled into ProviderConnection that is much simpler
end note
box "BuildActionExecuter chain in :launcher"

		merged, next := mergeRuneSets(&test.left, &test.right, test.leftPC, test.rightPC)
		if !slices.Equal(merged, test.merged) {
			t.Errorf("mergeRuneSet :%d (%v, %v) merged\n have\n%v\nwant\n%v", ix, test.left, test.right, merged, test.merged)
		}
		if !slices.Equal(next, test.next) {
			t.Errorf("mergeRuneSet :%d(%v, %v) next\n have\n%v\nwant\n%v", ix, test.left, test.right, next, test.next)
		}
	}
}

    @Override
    public int compare(@CheckForNull Object left, @CheckForNull Object right) {
      if (left == right) {
        return 0;
      } else if (left == null) {
        return -1;
      } else if (right == null) {
        return 1;
      }
      int leftCode = identityHashCode(left);
      int rightCode = identityHashCode(right);
      if (leftCode != rightCode) {
        return leftCode < rightCode ? -1 : 1;

The benefit of raising an exception over `return`ing a value will be more evident in the section about Dependencies and Security.

package org.sample.numberutils;

public class Numbers {
   public static int add(int left, int right) { return left + right; }

    font-size: 10pt;
}

th, td {
    white-space: nowrap;
    padding-top: 5px;
    padding-bottom: 5px;
    padding-left: 12px;
    padding-right: 12px;
    text-align: left;
    vertical-align: bottom;
}

th.numeric, td.numeric {
    text-align: right;
}

.empty {
    color: #a0a0a0;
    font-size: 8pt;
}

.more-detail {
    color: #a0a0a0;
    font-size: 8pt;
}