* limitations under the License.
 */

package org.gradle.internal.typeconversion;

import org.gradle.internal.exceptions.DiagnosticsVisitor;

public class IntegerFromCharSequenceNotationConverter implements NotationConverter<CharSequence, Integer> {

    @Override
    public void convert(CharSequence notation, NotationConvertResult<? super Integer> result) throws TypeConversionException {
        try {

 */

package org.gradle.internal.typeconversion

import spock.lang.Specification

class NotationConverterToNotationParserAdapterTest extends Specification {
    def converter = Mock(NotationConverter)
    def parser = new NotationConverterToNotationParserAdapter(converter)

    def "converts notation"() {
        given:

import groovy.lang.Closure;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;
import org.gradle.internal.exceptions.DiagnosticsVisitor;

public class ClosureToSpecNotationConverter<T> implements NotationConverter<Closure, Spec<T>> {
    private final Class<T> type;

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

    @Override

package org.gradle.internal.typeconversion;

import org.gradle.api.NonNullApi;
import org.gradle.internal.exceptions.DiagnosticsVisitor;

@NonNullApi
public class LongFromCharSequenceNotationConverter implements NotationConverter<CharSequence, Long> {

    @Override
    public void convert(CharSequence notation, NotationConvertResult<? super Long> result) throws TypeConversionException {
        try {

/**
 * A parser from notations of type {@link N} to a result of type {@link T}. This interface is used by clients to perform the parsing. To implement a parser, you should use {@link NotationConverter}
 * instead.
 */
public interface NotationParser<N, T> {
    /**
     * @throws UnsupportedNotationException When the supplied notation is not handled by this parser.

 * limitations under the License.
 */

package org.gradle.internal.typeconversion;

import org.gradle.internal.exceptions.DiagnosticsVisitor;

public abstract class TypedNotationConverter<N, T> implements NotationConverter<Object, T> {

    private final Class<N> typeToken;

    public TypedNotationConverter(Class<N> typeToken) {
        assert typeToken != null : "typeToken cannot be null";
        this.typeToken = typeToken;

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;
import org.gradle.internal.typeconversion.NotationParserBuilder;

 * limitations under the License.
 */

package org.gradle.internal.typeconversion;

public interface NotationConvertResult<T> {
    boolean hasResult();

    /**
     * Invoked when a {@link NotationConverter} is able to convert a notation to a result.
     */
    void converted(T result);

 * limitations under the License.
 */

package org.gradle.internal.typeconversion;

import org.gradle.internal.exceptions.DiagnosticsVisitor;

class CharSequenceNotationParser implements NotationConverter<String, String> {
    @Override
    public void convert(String notation, NotationConvertResult<? super String> result) throws TypeConversionException {
        result.converted(notation);
    }

    @Override

 * limitations under the License.
 */

package org.gradle.internal.typeconversion

import spock.lang.Specification

class CharSequenceNotationConverterTest extends Specification {
    def target = Mock(NotationConverter)
    def result = Mock(NotationConvertResult)
    def converter = new CharSequenceNotationConverter<Object, Number>(target)

    def "ignores notations that are not a CharSequence instance"() {
        when: