*/
    @Input
    abstract Property<String> getRemoteUri()

    /**
     * Git reference to use.
     */
    @Input
    abstract Property<String> getRef()

    /**
     * Relative path of a subdirectory within the git repository to use as the project template base directory.
     *
     * If unset, the root directory of the git repository is used.
     */
    @Input

                    String key = attributeDoc.getKey();
                    if (inheritedValueTitleMapping.get(key) != null) {
                        ExtraAttributeDoc newAttribute = new ExtraAttributeDoc(inheritedValueTitleMapping.get(key), attributeDoc.getValueCell());
                        additionalValues.put(newAttribute.getKey(), newAttribute);
                    } else {

    public Map<String, String> obtain() {
        String prefix = getParameters().getPrefix().getOrElse("");

        return itemsToFilter()
            .filter(e -> e.getKey().startsWith(prefix))
            .collect(ImmutableMap.toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
    }

    protected abstract Stream<Map.Entry<String, String>> itemsToFilter();

                    for (String className : entry.getValue()) {
                        warning.append("    * " + className + "\n");
                    }
                    getLogger().warn(warning.toString());
                }
                mappingFileWriter.print(entry.getKey());
                mappingFileWriter.print(":");

import org.gradle.api.Incubating;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to the getter for a property on a {@link RuleSource} to denote that the property defines an implicit input for all rules defined by the rule source.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Incubating

                @Internal
                public ListProperty<Integer> getList() {
                    return list;
                }

                @Internal
                public SetProperty<Integer> getSet() {
                    return set;
                }

                @Internal
                public MapProperty<Integer, Boolean> getMap() {
                    return map;
                }

    }

    @Override
    public void addAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> entries, Map<K, V> dest) {
        for (Map.Entry<? extends K, ? extends V> entry : entries) {
            add(entry.getKey(), entry.getValue(), dest);
        }
    }

        classes.put(fullyQualifiedClassName, metaData);
    }

    @Override
    public void each(Closure cl) {
        for (Map.Entry<String, T> entry : classes.entrySet()) {
            cl.call(new Object[]{entry.getKey(), entry.getValue()});
        }
    }

    public void each(Action<? super T> action) {
        for (T t : classes.values()) {
            action.execute(t);
        }
    }

                "Element '$name' of type '${it::class.java.name}' from container '$this' cannot be cast to '${T::class.qualifiedName}'."
            )
    }


/**
 * Delegated property getter that locates extensions.
 */
inline operator fun <reified T : Any> ExtensionContainer.getValue(thisRef: Any?, property: KProperty<*>): T =
    getByName<T>(property.name)


/**

                        for (Map.Entry<ModelActionRole, ModelAction> actionInRole : initializer.getActions(ModelReference.of(modelPath), descriptor).entries()) {
                            ModelActionRole role = actionInRole.getKey();
                            ModelAction action = actionInRole.getValue();
                            node.applyToSelf(role, action);
                        }
                    }
                });