r.isSubscribed(StringBuilder)

        r.registerEagerAddAction(StringBuilder, Stub(Action))

        r.isSubscribed(null)
        r.isSubscribed(String)
        r.isSubscribed(CharSequence)
        r.isSubscribed(StringBuilder)
    }

        this.baseType = baseType;
        this.decorator = decorator;
    }

    @Override
    public boolean isSubscribed(@Nullable Class<? extends T> type) {
        if (baseTypeSubscribed) {
            return true;
        }
        if (subscribedTypes != null) {
            if (type == null) {
                return true;

import javax.annotation.Nullable;

/**
 * Tracks which types are subscribed to by eager event listeners. Lazy elements of a
 * subscribed type should be immediately realized when added to a container.
 */
public interface EventSubscriptionVerifier<T> {

    /**
     * Determines whether events should be emitted for elements of the given type.
     */
    boolean isSubscribed(@Nullable Class<? extends T> type);

        boolean added = pending.add(collector);
        // TODO: We likely want to also immediately realize ChangingValue providers in the
        //  onValueChange callback above.
        if (subscriptionVerifier.isSubscribed(provider.getType())) {
            realize(Collections.singleton(collector));

            // Ugly backwards-compatibility hack. Previous implementations would notify listeners without

import org.gradle.internal.ImmutableActionSet;

import javax.annotation.Nullable;

public interface CollectionEventRegister<T> extends EventSubscriptionVerifier<T> {

    @Override
    boolean isSubscribed(@Nullable Class<? extends T> type);

    /**
     * Returns a snapshot of the current set of actions to run when an element is added.
     */
    ImmutableActionSet<T> getAddActions();

        this.subscriptionVerifier = subscriptionVerifier;
    }

    protected boolean addPendingElement(Element<T> element) {
        boolean added = inserted.add(element);
        if (subscriptionVerifier.isSubscribed(element.getType())) {
            element.realize();

            // Ugly backwards-compatibility hack. Previous implementations would notify listeners without

   *     broadcasting a new event based on the error.
   * @param event The event object that caused the subscriber to throw.
   * @param subscriber The source subscriber context.
   * @param subscriberMethod the subscribed method.
   */
  SubscriberExceptionContext(
      EventBus eventBus, Object event, Object subscriber, Method subscriberMethod) {
    this.eventBus = checkNotNull(eventBus);
    this.event = checkNotNull(event);

	// 1. no subscribed resources change from spontaneous delta request.
	// 2. subscribed resources changes from ACK.
	if spontaneousReq && !subChanged || !spontaneousReq && subChanged {
		deltaLog.Errorf("ADS:%s: Subscribed resources check mismatch: %v vs %v", stype, spontaneousReq, subChanged)
		if features.EnableUnsafeAssertions {

	var addresses sets.String
	if isReq {
		// this is from request, we only send response for the subscribed address
		// At t0, a client request A, we only send A and additional resources back to the client.
		// At t1, a client request B, we only send B and additional resources back to the client, no A here.
		addresses = req.Delta.Subscribed
	} else {
		if w.Wildcard {
			addresses = updatedAddresses
		} else {

   *     broadcasting a new event based on the error.
   * @param event The event object that caused the subscriber to throw.
   * @param subscriber The source subscriber context.
   * @param subscriberMethod the subscribed method.
   */
  SubscriberExceptionContext(
      EventBus eventBus, Object event, Object subscriber, Method subscriberMethod) {
    this.eventBus = checkNotNull(eventBus);
    this.event = checkNotNull(event);