assertCanMutate();
        MapSupplier<K, V> explicitValue = getExplicitValue(defaultValue).absentIgnoringIfNeeded(ignoreAbsent);
        setSupplier(explicitValue.plus(collector.absentIgnoringIfNeeded(ignoreAbsent)));
    }

    private Configurer getConfigurer() {
        return getConfigurer(false);
    }

    private Configurer getConfigurer(boolean ignoreAbsent) {

import org.gradle.internal.declarativedsl.schemaBuilder.ConfigureLambdaHandler
import org.gradle.internal.declarativedsl.schemaBuilder.kotlinFunctionAsConfigureLambda
import org.gradle.internal.declarativedsl.schemaBuilder.plus
import org.gradle.internal.declarativedsl.schemaBuilder.treatInterfaceAsConfigureLambda


/**
 * Defines configuring lambdas for schema building purposes as one of:

 * limitations under the License.
 */

package org.gradle.model.internal.core;

/**
 * An open set of criteria that selects model nodes. A node must satisfy all of the criteria defined by {@link ModelPredicate} plus
 * those defined by {@link #matches(MutableModelNode)}.
 */
public abstract class ModelSpec extends ModelPredicate {
    /**
     * Returns if the node matches this predicate.
     */

        for (GlobalCache globalCache : globalCaches) {
            for (File file : globalCache.getGlobalCacheRoots()) {
                globalCacheRoots = globalCacheRoots.plus(file);
            }
        }
        this.globalCacheRoots = globalCacheRoots;
    }

    @Override
    public boolean isInsideGlobalCache(String path) {
        return globalCacheRoots.contains(path);
    }

            checkThatNothingExistsInNewWatchableHierarchy(watchableHierarchyPath, root);
            hierarchies.addFirst(watchableHierarchy);
            watchableFiles = watchableFiles.plus(watchableHierarchy);
        } else {
            hierarchies.remove(watchableHierarchy);
            hierarchies.addFirst(watchableHierarchy);
        }

// together. Since all Go sources in a Go package are compiled together,
// there's one CompilationUnit per package that represents all Go sources in
// that package, plus one for each assembly file.
//
// Equivalently, there's one CompilationUnit per object file in each Library
// loaded by the linker.
//
// These are used for both DWARF and pclntab generation.
type CompilationUnit struct {

        file('other/add-one.txt').createFile()
        file('other/a/add-two.txt').createFile()
        buildFile """
            def files = fileTree(dir: 'files').minus(fileTree(dir: 'files/b')).plus(fileTree(dir: 'other'))
            task copy(type: Copy) {
                from files
                into 'dest'
            }
        """

        when:
        run 'copy'

        then:

*[FEss Site Search](https://github.com/codelibs/fess-site-search)* est une alternative libre à [Google Site Search](https://enterprise.google.com/search/products/gss.html). Pour plus de détails, jetez un oeil à [FSS JS Generator documentation](https://fss-generator.codelibs.org/docs/manual).

## Website

[fess.codelibs.org](https://fess.codelibs.org/)

## Incidents/Questions

 */
interface MapSupplier<K, V> extends ValueSupplier {
    Value<? extends Map<K, V>> calculateValue(ValueConsumer consumer);

    Value<? extends Set<K>> calculateKeys(ValueConsumer consumer);

    MapSupplier<K, V> plus(MapCollector<K, V> collector);

    /**
     * Returns a view of this supplier that may calculate its value as empty if it would be missing.
     */
    MapSupplier<K, V> absentIgnoring();

	output := filepath.Join(tmpdir, "fma.exe")
	cmd := testenv.Command(t, gocmd, "build", "-o", output, source)
	// The hash-dependence on file path name is dodged by specifying "all hashes ending in 1" plus "all hashes ending in 0"
	// i.e., all hashes.  This will print all the FMAs; this test is only interested in one of them (that should appear near the end).