*
 * <p>This interface represents an SPI used to implement notation parsers, not the API to use to perform the conversions. Use {@link NotationParser} instead for this.
 */
public interface NotationConverter<N, T> {
    /**
     * Attempt to convert the given notation.
     *
     * @throws TypeConversionException when the notation is recognized but cannot be converted for some reason.
     */

import org.gradle.internal.exceptions.DiagnosticsVisitor;

import java.util.List;

public class CompositeNotationConverter<N, T> implements NotationConverter<N, T> {
    private final List<NotationConverter<? super N, ? extends T>> converters;

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

    @Override

    }

    private NotationParser<N, T> create() {
        NotationConverter<? super N, ? extends T> notationConverter;
        if (notationParsers.size() == 1) {
            notationConverter = notationParsers.get(0);
        } else {
            notationConverter = new CompositeNotationConverter<>(notationParsers);
        }

        expect:
        parser.parseNotation(12) == "[12]"
    }

    def "can add multiple converters"() {
        def converter1 = Mock(NotationConverter)
        def converter2 = Mock(NotationConverter)

        given:
        _ * converter1.convert(12, _) >> { Object n, NotationConvertResult result -> result.converted("[12]") }

import org.gradle.internal.exceptions.DiagnosticsVisitor;

class CharSequenceNotationConverter<N, T> implements NotationConverter<N, T> {
    private final NotationConverter<? super String, ? extends T> delegate;

    public CharSequenceNotationConverter(NotationConverter<? super String, ? extends T> delegate) {
        this.delegate = delegate;
    }

    @Override

import org.gradle.cache.internal.CrossBuildInMemoryCache;
import org.gradle.internal.exceptions.DiagnosticsVisitor;

/**
 * A {@link NotationConverter} that caches the result of conversion across build invocations.
 */
public class CrossBuildCachingNotationConverter<T> implements NotationConverter<Object, T> {
    private final CrossBuildInMemoryCache<Object, T> cache;
    private final NotationConverterToNotationParserAdapter<Object, T> delegate;

import org.gradle.internal.exceptions.DiagnosticsVisitor;

class TypeFilteringNotationConverter<N, S, T> implements NotationConverter<N, T> {
    private final Class<S> type;
    private final NotationConverter<? super S, ? extends T> delegate;

    public TypeFilteringNotationConverter(Class<S> type, NotationConverter<? super S, ? extends T> delegate) {
        this.type = type;
        this.delegate = delegate;
    }

    @Override

                                                  Interner<String> stringInterner) {
        NotationConverter<String, ? extends ExternalModuleDependency> stringNotationConverter =
            new DependencyStringNotationConverter<>(instantiator, DefaultExternalModuleDependency.class, stringInterner);
        NotationConverter<MinimalExternalModuleDependency, ? extends MinimalExternalModuleDependency> minimalExternalDependencyNotationConverter =

            NotationConverter<CharSequence, JavaVersion> converter = new JavaVersionFromCharSequenceNotationConverter();
            return Cast.uncheckedCast(new NotationConverterToNotationParserAdapter<>(converter));
        } else if (targetType.isEnum()) {
            @SuppressWarnings({"rawtypes", "unchecked"})

import org.gradle.internal.typeconversion.NotationConvertResult;
import org.gradle.internal.typeconversion.NotationConverter;
import org.gradle.internal.typeconversion.TypeConversionException;

public class DependencyProjectNotationConverter implements NotationConverter<Project, ProjectDependency> {

    private final DefaultProjectDependencyFactory factory;