private final ExecutionList executionList = new ExecutionList();

    // This allows us to only start up a thread waiting on the delegate future when the first
    // listener is added.
    private final AtomicBoolean hasListeners = new AtomicBoolean(false);

    // The delegate future.
    private final Future<V> delegate;

    ListenableFutureAdapter(Future<V> delegate) {
      this(delegate, defaultAdapterExecutor);
    }

        expect:
        !manager.hasListeners(TestFooListener)

        when:
        manager.getBroadcaster(TestFooListener)

        then:
        !manager.hasListeners(TestFooListener)

        when:
        manager.addListener(fooListener1)

        then:
        manager.hasListeners(TestFooListener)
        !manager.hasListeners(TestBarListener)

        when:

    private final ExecutionList executionList = new ExecutionList();

    // This allows us to only start up a thread waiting on the delegate future when the first
    // listener is added.
    private final AtomicBoolean hasListeners = new AtomicBoolean(false);

    // The delegate future.
    private final Future<V> delegate;

    ListenableFutureAdapter(Future<V> delegate) {
      this(delegate, defaultAdapterExecutor);
    }

        }
    }

    private void executeActions(TaskInternal task, @Nullable InputChangesInternal inputChanges) {
        boolean hasTaskListener = listenerManager.hasListeners(org.gradle.api.execution.TaskActionListener.class) || listenerManager.hasListeners(org.gradle.api.execution.TaskExecutionListener.class);
        Iterator<InputChangesAwareTaskAction> actions = new ArrayList<>(task.getTaskActions()).iterator();

     *
     * @param listenerClass The type of listener to check.
     * @return True if a listener of the specified type is currently registered, false otherwise.
     */
    <T> boolean hasListeners(Class<T> listenerClass);

    /**
     * Returns a broadcaster for the given listenerClass. Any method invoked on the broadcaster is forwarded to all registered

                allLoggers.put(logger, details);
            }
        }
        if (details != null) {
            details.useAsLogger();
        }
    }

    @Override
    public <T> boolean hasListeners(Class<T> listenerClass) {
        EventBroadcast<T> broadcaster = getBroadcasterInternal(listenerClass);
        return !broadcaster.listeners.isEmpty();
    }

    @Override

    abstract boolean casListeners(
        AbstractFuture<?> future, @CheckForNull Listener expect, Listener update);

    /** Performs a GAS operation on the {@link #waiters} field. */
    abstract Waiter gasWaiters(AbstractFuture<?> future, Waiter update);

    /** Performs a GAS operation on the {@link #listeners} field. */
    abstract Listener gasListeners(AbstractFuture<?> future, Listener update);

    abstract boolean casListeners(
        AbstractFuture<?> future, @CheckForNull Listener expect, Listener update);

    /** Performs a GAS operation on the {@link #waiters} field. */
    abstract Waiter gasWaiters(AbstractFuture<?> future, Waiter update);

    /** Performs a GAS operation on the {@link #listeners} field. */
    abstract Listener gasListeners(AbstractFuture<?> future, Listener update);

s.error)throw this.error;if(this.processed)return this.result;if(this.processed=!0,this.processing)throw this.getAsyncError();for(let e of this.plugins){let t=this.runOnRoot(e);if(Sr(t))throw this.getAsyncError()}if(this.prepareVisitors(),this.hasListener){let e=this.result.root;for(;!e[qe];)e[qe]=!0,this.walkSync(e);if(this.listeners.OnceExit)if(e.type==="document")for(let t of e.nodes)this.visitSync(this.listeners.OnceExit,t);else this.visitSync(this.listeners.OnceExit,e)}return this.result}st...

if(!this._hasListeners()){this._cleanup();this._isSetup=false;}},_setup:function(){this._observeContentElements(this.domApi.childNodes);},_cleanup:function(){this._unobserveContentElements(this.domApi.childNodes);},_hasListeners:function(){return Boolean(this._liste...