+ ")";
    }
  }

  /**
   * Returns a supplier that caches the instance supplied by the delegate and removes the cached
   * value after the specified time has passed. Subsequent calls to {@code get()} return the cached
   * value if the expiration time has not passed. After the expiration time, a new value is
   * retrieved, cached, and returned. See: <a
   * href="http://en.wikipedia.org/wiki/Memoization">memoization</a>

        return importModel;
    }

    private static <T> T cache(
            ModelCache cache, String groupId, String artifactId, String version, String tag, Callable<T> supplier) {
        Supplier<T> s = asSupplier(supplier);
        if (cache == null) {
            return s.get();
        } else {
            return cache.computeIfAbsent(groupId, artifactId, version, tag, s);
        }
    }

    String CRAWLER_DOCUMENT_CACHE_ENABLED = "crawler.document.cache.enabled";

    /** The key of the configuration. e.g. 2621440 */
    String CRAWLER_DOCUMENT_CACHE_MAX_SIZE = "crawler.document.cache.max.size";

    /** The key of the configuration. e.g. text/html */
    String CRAWLER_DOCUMENT_CACHE_SUPPORTED_MIMETYPES = "crawler.document.cache.supported.mimetypes";

            List<? extends InterpolationPostProcessor> postProcessors,
            ModelBuilderRequest request,
            ModelProblemCollector problems) {
        Map<String, String> cache = new HashMap<>();
        StringSearchInterpolator interpolator = new StringSearchInterpolator();
        interpolator.setCacheAnswers(true);
        for (ValueSource vs : valueSources) {

     */
    Path getPathForLocalArtifact(@Nonnull Artifact artifact);

    /**
     * Gets the relative path for an artifact cached from a remote repository.
     * Note that the artifact need not actually exist yet at the returned location,
     * the path merely indicates where the artifact would eventually be stored.
     * <p>

        if (lookup == null) {
            return customLifecycles != null ? customLifecycles : new HashMap<>();
        }

        // Lifecycles cannot be cached as extensions might add custom lifecycles later in the execution.
        try {
            Map<String, Lifecycle> lifecycles = new HashMap<>(lookup.lookupMap(Lifecycle.class));

                throw new PluginManagerException(plugin, e.getMessage(), e);
            }
        }
        pluginArtifactsCache.register(project, cacheKey, recordArtifacts);

        // create and cache extensions realms
        final ExtensionRealmCache.Key extensionKey = extensionRealmCache.createKey(artifacts);
        extensionRecord = extensionRealmCache.get(extensionKey);
        if (extensionRecord == null) {

  /** Number of (unsynchronized) retries in the containsValue method. */
  static final int CONTAINS_VALUE_RETRIES = 3;

  /**
   * Number of cache access operations that can be buffered per segment before the cache's recency
   * ordering information is updated. This is used to avoid lock contention by recording a memento

import java.util.function.Supplier;

import org.apache.maven.api.services.Source;

/**
 * Caches auxiliary data used during model building like already processed raw/effective models. The data in the cache
 * is meant for exclusive consumption by the model builder and is opaque to the cache implementation. The cache key is
 * formed by a combination of group id, artifact id, version and tag. The first three components generally refer to the

import org.apache.maven.api.services.xml.XmlReaderRequest;

@Named
@Singleton
public class DefaultSuperPomProvider implements SuperPomProvider {

    private final ModelProcessor modelProcessor;

    /**
     * The cached super POM, lazily created.
     */
    private static final Map<String, Model> SUPER_MODELS = new ConcurrentHashMap<>();

    @Inject
    public DefaultSuperPomProvider(ModelProcessor modelProcessor) {