/**
     * Returns the root directory of this cache builder factory. You should avoid using this method and instead use one of the other methods.
     */
    File getRootDir();

    /**
     * Returns the base directory that would be used for a Gradle-version specific cache builder created by this factory.
     */
    File baseDirForCache(String key);

    /**

        DefaultSerializerRegistry registry = new DefaultSerializerRegistry(false);

        BaseSerializerFactory factory = new BaseSerializerFactory();
        Serializer<LogLevel> logLevelSerializer = factory.getSerializerFor(LogLevel.class);
        Serializer<Throwable> throwableSerializer = factory.getSerializerFor(Throwable.class);

        // Log events

class DependencyManagementProjectScopeServices implements ServiceRegistrationProvider {
    void configure(ServiceRegistration registration) {
        registration.add(DefaultExternalResourceFileStore.Factory.class);
        registration.add(DefaultArtifactIdentifierFileStore.Factory.class);
        registration.add(TransformStepNodeDependencyResolver.class);
    }

    /** This is needed in order to get the {@code taskDependencyFactory} from the current project. */

            }
        }
}

/**
 * Uses the given [factory] to merge all providers of type [T] with the given [mergeTargets] strategy. Other providers (not of type [T]) are
 * added to the resulting composite provider unmerged.
 */
public inline fun <P : KotlinComposableProvider, reified T : P> List<P>.mergeSpecificProviders(
    factory: KotlinCompositeProviderFactory<P>,
    crossinline mergeTargets: (List<T>) -> P,
): P {

        lock.lock();
        try {
            ClassLoader classLoader = classLoaderIds.getIfPresent(details.uuid);
            if (classLoader != null) {
                return classLoader;
            }

            classLoader = factory.transform(details);
            classLoaderIds.put(details.uuid, classLoader);

    public DefaultPluginArtifactRepositories(Factory<DependencyResolutionServices> factory, RepositoryHandlerInternal sharedRepositories) {
        // Create a copy of the shared repository container, so that mutations (eg adding the portal repo) are not reflected in the shared container
        dependencyResolutionServices = factory.create();
        this.sharedRepositories = sharedRepositories;

    private Model read(InputStream input, Path pomFile, Map<String, ?> options) throws IOException {
        try {
            XMLInputFactory factory = new com.ctc.wstx.stax.WstxInputFactory();
            factory.setProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, false);
            XMLStreamReader parser = factory.createXMLStreamReader(input);

            InputSource source = getSource(options);
            boolean strict = isStrict(options);

        // by creating the COW data structure from a list.
        CopyOnWriteArraySet(readList())
    }
)


fun <T : MutableCollection<Any?>> collectionCodec(factory: (Int) -> T) = codec(
    { writeCollection(it) },
    { readCollectionInto(factory) }
)


/**
 * Decodes HashMap instances as LinkedHashMap to preserve original iteration order.
 */

    override val factoryName: String
        get() = withValidityAssertion { diagnostic.factory.name }

    override val defaultMessage: String
        get() = withValidityAssertion {
            @Suppress("UNCHECKED_CAST")
            val factory = diagnostic.factory as DiagnosticFactory<UnboundDiagnostic>?
            return factory?.defaultRenderer?.render(diagnostic)

                    TikaExtractor tikaExtractor = container.getComponent("tikaExtractor");
                    LhaExtractor lhaExtractor = container.getComponent("lhaExtractor");
                    factory.addExtractor("text/plain", tikaExtractor);
                    factory.addExtractor("text/html", tikaExtractor);
                    factory.addExtractor("application/x-lha", lhaExtractor);