/**
 * 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.

     *
     * @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);
        }
    }

package org.gradle.internal.service;

import org.gradle.internal.exceptions.Contextual;

/**
 * Thrown when a service instance cannot be created.
 */
@Contextual
public class ServiceCreationException extends ServiceLookupException {
    public ServiceCreationException(String message) {
        super(message);
    }

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

 * limitations under the License.
 */

package org.gradle.internal.service;

/**
 * Thrown when there is some validation problem with a service.
 */
public class ServiceValidationException extends ServiceLookupException {
    public ServiceValidationException(String message) {
        super(message);
    }