public CompositeNotationConverter(List<NotationConverter<? super N, ? extends T>> converters) {
        this.converters = converters;
    }

    @Override
    public void convert(N notation, NotationConvertResult<? super T> result) throws TypeConversionException {
        for (int i = 0; !result.hasResult() && i < converters.size(); i++) {
            NotationConverter<? super N, ? extends T> converter = converters.get(i);

    private final Class<T> type;

    public ClosureToSpecNotationConverter(Class<T> type) {
        this.type = type;
    }

    @Override
    public void convert(Closure notation, NotationConvertResult<? super Spec<T>> result) throws TypeConversionException {
        Spec<T> spec = Specs.convertClosureToSpec(notation);
        result.converted(spec);
    }

    @Override

import org.gradle.internal.exceptions.DiagnosticsVisitor;
import org.gradle.internal.reflect.Instantiator;
import org.gradle.internal.typeconversion.MapNotationConverter;
import org.gradle.internal.typeconversion.NotationConvertResult;
import org.gradle.internal.typeconversion.NotationConverter;
import org.gradle.internal.typeconversion.NotationConverterToNotationParserAdapter;
import org.gradle.internal.typeconversion.NotationParser;

import org.gradle.api.internal.attributes.ImmutableAttributesFactory;
import org.gradle.internal.exceptions.DiagnosticsVisitor;
import org.gradle.internal.reflect.Instantiator;
import org.gradle.internal.typeconversion.NotationConvertResult;
import org.gradle.internal.typeconversion.NotationConverter;
import org.gradle.internal.typeconversion.NotationConverterToNotationParserAdapter;
import org.gradle.internal.typeconversion.NotationParser;

    /**
     * Attempt to convert the given notation.
     *
     * @throws TypeConversionException when the notation is recognized but cannot be converted for some reason.
     */
    void convert(N notation, NotationConvertResult<? super T> result) throws TypeConversionException;

    /**
     * Describes the formats that this converter accepts.
     */
    void describe(DiagnosticsVisitor visitor);

        return result.result;
    }

    @Override
    public void describe(DiagnosticsVisitor visitor) {
        converter.describe(visitor);
    }

    private static class ResultImpl<T> implements NotationConvertResult<T> {
        private boolean hasResult;
        private T result;

        @Override
        public boolean hasResult() {
            return hasResult;
        }

        @Override

        this.cache = cache;
        this.delegate = new NotationConverterToNotationParserAdapter<>(delegate);
    }

    @Override
    public void convert(Object notation, NotationConvertResult<? super T> result) throws TypeConversionException {
        T value = cache.get(notation, () -> delegate.parseNotation(notation));
        result.converted(value);
    }

    @Override

package org.gradle.internal.typeconversion

import spock.lang.Specification

class TypeFilteringNotationConverterTest extends Specification {
    def target = Mock(NotationConverter)
    def result = Mock(NotationConvertResult)
    def converter = new TypeFilteringNotationConverter<Number, BigDecimal, String>(BigDecimal, target)

    def "ignores notation when it is not an instance of the target type"() {
        when:

public class JavaVersionFromCharSequenceNotationConverter implements NotationConverter<CharSequence, JavaVersion> {
    @Override
    public void convert(CharSequence notation, NotationConvertResult<? super JavaVersion> result) throws TypeConversionException {
        try {
            result.converted(JavaVersion.toVersion(notation));
        } catch (IllegalArgumentException e) {

@NonNullApi
public class DoubleFromCharSequenceNotationConverter implements NotationConverter<CharSequence, Double> {

    @Override
    public void convert(CharSequence notation, NotationConvertResult<? super Double> result) throws TypeConversionException {
        try {
            result.converted(Double.valueOf(notation.toString()));
        } catch (NumberFormatException ex) {