Class<? extends ValueSource<T, P>> valueSourceType,
        @Nullable Class<P> parametersType,
        @Nullable P parameters
    );

    /**
     * The listener that is notified when the value of the {@code ValueSource} is computed. There is no ordering guarantees with the
     * {@link ValueListener#valueObtained(ValueListener.ObtainedValue, ValueSource)}.
     */
    @EventScope(Scope.Build.class)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.tooling.events;

/**
 * A listener which is notified when operations that are executed as part of running a build make progress.
 *
 * @see org.gradle.tooling.LongRunningOperation#addProgressListener(ProgressListener)

     * Process the specified file or directory.  If it is a directory, then its contents
     * (but not the directory itself) will be checked with {@link #isAllowed(FileTreeElement, Spec)} and notified to
     * the listener.  If it is a file, the file will be checked and notified.
     */
    public void visitFrom(FileVisitor visitor, File fileOrDirectory, RelativePath path, AtomicBoolean stopFlag) {
        Spec<FileTreeElement> spec = patternSet.getAsSpec();

 *
 * There is one global listener for the life of the build runtime.
 * Listeners must be sure to remove themselves if they want to only listen for a single build.
 *
 * Listeners are notified in registration order.
 * Started and progress notifications are emitted in registration order,
 * while finished notifications are emitted in reverse registration order.
 *

	ValidatePlugin(pluginName string, endpoint string, versions []string) error
	// RegisterPlugin is called so that the plugin can be registered by any
	// plugin consumer
	// Error encountered here can still be Notified to the plugin.
	RegisterPlugin(pluginName, endpoint string, versions []string, pluginClientTimeout *time.Duration) error
	// DeRegisterPlugin is called once the pluginwatcher observes that the socket has
	// been deleted.

    boolean isEnabled(BuildEventSubscriptions subscriptions);

    Class<DETAILS> getDetailsType();

    /**
     * Returns the trackers that are used by this mapper. If this mapper is enabled, then the trackers should be notified of
     * build operation execution. If this mapper is not enabled, the trackers can be ignored.
     */
    default List<? extends BuildOperationTracker> getTrackers() {
        return Collections.emptyList();
    }

 * limitations under the License.
 */

package org.gradle.internal.session;

import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

/**
 * A listener that is notified when a session is started and completed. No more than one session may be active at any time.
 *

        return singleRun;
    }

    @Override
    public void notifyOnUnhealthy(final Action<? super String> listener) {
        /*
            The semantics of this method are that the given action should be notified if the
            Daemon is going to be terminated at the end of this build.
            It is not a generic outlet for “expiry events”.

         *
         * <p>If the operation fails, build will fail with the appropriate exception. The handler won't be notified in case of failure.
         *
         * @param buildAction The action to run in the specified build phase.
         * @param handler The handler to supply the result of the given action to.

     * The action will be invoked at-most once during a build.
     * It will only be invoked for the build in which it was registered (i.e. not subsequent builds).
     * Each action provided to each invocation of this message will be notified.
     * <p>
     * The action receives a free-form, human friendly, string describing why the Daemon needs to be shut down.
     */
    void notifyOnUnhealthy(Action<? super String> listener);