/**
 * Thrown when there is some failure locating a service.
 */
@UsedByScanPlugin
public class ServiceLookupException extends RuntimeException {
    public ServiceLookupException(String message) {
        super(message);
    }

    public ServiceLookupException(String message, Throwable cause) {
        super(message, cause);
    }

        }

        @Override
        public <T> T get(Class<T> serviceType) throws UnknownServiceException, ServiceLookupException {
            return serviceRegistry.get(serviceType);
        }

        @Override
        public <T> List<T> getAll(Class<T> serviceType) throws ServiceLookupException {
            return serviceRegistry.getAll(serviceType);
        }

        @Override

     */
    @Override
    Object get(Type serviceType) throws UnknownServiceException, ServiceLookupException;

    /**
     * Locates the service of the given type, returning null if no such service.
     *
     * @param serviceType The service type.
     * @return The service instance. Returns {@code null} if no such service exists.

import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.internal.tasks.NodeExecutionContext;
import org.gradle.internal.concurrent.CompositeStoppable;
import org.gradle.internal.service.ServiceLookupException;
import org.gradle.internal.service.ServiceRegistry;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.Closeable;
import java.io.IOException;

/**

     *
     * @param serviceType The service type.
     * @return The service instance. Returns {@code null} if no such service exists.
     * @throws ServiceLookupException On failure to lookup the specified service.
     */
    @Nullable
    Object find(Type serviceType) throws ServiceLookupException;

    /**
     * Locates the service of the given type, throwing an exception if no such service is located.
     *

        injectedServices.find(SomeParams)

        then:
        def e = thrown(ServiceLookupException)
        e.message == "Cannot query the parameters of an instance of SomeAction that takes no parameters."

        when:
        injectedServices.get(SomeParams)

        then:
        def e2 = thrown(ServiceLookupException)

 */

package org.gradle.api.internal.tasks;

import org.gradle.api.NonNullApi;
import org.gradle.internal.service.ServiceLookupException;

@NonNullApi
public interface NodeExecutionContext {
    /**
     * Locates the given execution service.
     */
    <T> T getService(Class<T> type) throws ServiceLookupException;

    /**
     * Whether this context is coming from an execution graph.
     * <p>

        try {
            return findServiceImplementations(serviceType);
        } catch (ServiceLookupException e) {
            throw e;
        } catch (Exception e) {
            throw new ServiceLookupException(String.format("Could not determine implementation classes for service '%s'.", serviceType.getName()), e);
        }
    }

import org.gradle.internal.reflect.Types;
import org.gradle.internal.reflect.Types.TypeVisitResult;
import org.gradle.internal.service.ServiceLookup;
import org.gradle.internal.service.ServiceLookupException;
import org.gradle.internal.service.UnknownServiceException;
import org.gradle.process.ExecOperations;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.lang.annotation.Annotation;

            throw new UnsupportedOperationException()
        }

        @Override
        Object find(Type serviceType) throws ServiceLookupException {
            throw new UnsupportedOperationException()
        }

        @Override
        def <T> Factory<T> getFactory(Class<T> type) throws UnknownServiceException, ServiceLookupException {