this.versionIsRequired = versionIsRequired;
    }

    private static CapabilityNotationParser createSingletonConverter(boolean strict) {
        NotationParser<Object, Capability> parser = NotationParserBuilder.toType(Capability.class)
            .converter(new StringNotationParser(strict))
            .converter(strict ? new StrictCapabilityMapNotationParser() : new LenientCapabilityMapNotationParser())
            .toComposite();

public class ComponentSelectorParsers {

    private static final NotationParserBuilder<Object, ComponentSelector> BUILDER = NotationParserBuilder
            .toType(ComponentSelector.class)
            .fromCharSequence(new StringConverter())
            .converter(new MapConverter())
            .fromType(Project.class, new ProjectConverter());

    @Override
    public NotationParser<Object, ConfigurablePublishArtifact> create() {
        FileNotationConverter fileConverter = new FileNotationConverter();
        return NotationParserBuilder
                .toType(ConfigurablePublishArtifact.class)
                .converter(new DecoratingConverter())
                .converter(new ArchiveTaskNotationConverter())
                .converter(new FileProviderNotationConverter())

        this.ruleActionAdapter = ruleActionAdapter;
        this.moduleIdentifierNotationParser = NotationParserBuilder
            .toType(ModuleIdentifier.class)
            .fromCharSequence(new ModuleIdentifierNotationConverter(moduleIdentifierFactory))
            .toComposite();
    }

    /**
     * Sets the validator to invoke prior to each mutation.

        t.message == 'The strict version modifier (!!) must be appended to a valid version number'
    }

    def parse(def parser, def value) {
        return NotationParserBuilder.toType(Dependency).fromCharSequence(parser).toComposite().parseNotation(value)
    }

        NotationParser<Object, Dependency> notationParser = NotationParserBuilder
            .toType(Dependency.class)
            .noImplicitConverters()
            .fromCharSequence(stringNotationConverter)
            .fromType(MinimalExternalModuleDependency.class, minimalExternalDependencyNotationConverter)

        NotationParser<Object, ComponentSelector> projectSelectorNotationParser = NotationParserBuilder
            .toType(ComponentSelector.class)
            .fromCharSequence(new ProjectPathConverter(componentIdentifierFactory))
            .toComposite();
        return instantiator.newInstance(DefaultDependencySubstitutions.class,

    private static final Pattern ENCODED_URI = Pattern.compile("%([0-9a-fA-F]{2})");

    public static NotationParser<Object, Object> parser() {
        return NotationParserBuilder
            .toType(Object.class)
            .typeDisplayName("a File or URI")
            .noImplicitConverters()
            .converter(new FileOrUriNotationConverter())
            .toComposite();
    }

    @Override

        return builder(dslContext).toComposite();
    }

    private static NotationParserBuilder<Object, ModuleVersionSelector> builder(String dslContext) {
        return NotationParserBuilder
            .toType(ModuleVersionSelector.class)
            .fromCharSequence(new StringConverter())
            .converter(new MapConverter())
            .converter(new ProviderConverter(dslContext))

	t, ok := timeVal.ToTimestamp()
	if !ok {
		return nil, errNonTimestampArg
	}

	return extract(strings.ToUpper(e.Timeword), t)
}

func errUnsupportedCast(fromType, toType string) error {
	return fmt.Errorf("Cannot cast from %v to %v", fromType, toType)
}

func errCastFailure(msg string) error {
	return fmt.Errorf("Error casting: %s", msg)
}

// Allowed cast types
const (
	castBool      = "BOOL"