for (Object closeable : elements) {
            add(closeable);
        }
        return this;
    }

    public CompositeStoppable add(Object... elements) {
        for (Object closeable : elements) {
            add(closeable);
        }
        return this;
    }

    public synchronized CompositeStoppable add(Object closeable) {
        this.elements.add(toStoppable(closeable));

import org.gradle.internal.service.scopes.GradleUserHomeScopeServiceRegistry;
import org.gradle.internal.service.scopes.Scope;

import java.io.Closeable;
import java.util.function.Function;

/**
 * Encapsulates the state for a build session.
 */
public class BuildSessionState implements Closeable {
    private final GradleUserHomeScopeServiceRegistry userHomeScopeServiceRegistry;
    private final ServiceRegistry userHomeServices;

        registry.add(Closeable, {
            instant.closing
            thread.blockUntil.lookupDone
        } as Closeable)

        when:
        async {
            start() {
                registry.close()
            }
            start {
                thread.blockUntil.closing
                try {
                    registry.get(Closeable)
                } finally {

import org.gradle.internal.serialize.graph.runWriteOperation
import org.gradle.internal.serialize.graph.withPropertyTrace
import java.io.Closeable


internal
class ScopedFingerprintWriter<T>(
    private val writeContext: DefaultWriteContext
) : Closeable {
    override fun close() {
        // we synchronize access to all resources used by callbacks

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.internal.snapshot.FileSystemSnapshot;

import java.io.Closeable;
import java.time.Duration;
import java.util.Map;
import java.util.Optional;

/**
 * High-level controller for build-cache operations; can load and store {@link CacheableEntity}s with a given {@link BuildCacheKey}.

package org.gradle.kotlin.dsl.concurrent

import org.gradle.internal.concurrent.ExecutorFactory
import org.gradle.internal.service.Provides
import org.gradle.internal.service.ServiceRegistrationProvider

import java.io.Closeable
import java.time.Duration

import java.util.concurrent.ExecutorService
import java.util.concurrent.Future
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicReference


internal

import org.gradle.launcher.daemon.registry.DaemonRegistryServices;

import java.io.Closeable;
import java.util.concurrent.atomic.AtomicReference;

/**
 * Encapsulates the state of the daemon process.
 */
public class DaemonProcessState implements Closeable {
    private final BuildProcessState buildProcessState;

 * limitations under the License.
 */

package org.gradle.internal.serialize;

import java.io.Closeable;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputStreamBackedEncoder extends AbstractEncoder implements Closeable, FlushableEncoder {
    private final DataOutputStream outputStream;

import org.gradle.internal.service.scopes.Scope;

import java.io.Closeable;

/**
 * Encapsulates the state of a build process, such as the Gradle daemon. An instance is created for each process that runs a build.
 */
public class BuildProcessState implements Closeable {
    private final ServiceRegistry services;

    public BuildProcessState(
        final boolean longLiving,

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.cache;

import org.gradle.internal.serialize.Serializer;

import java.io.Closeable;
import java.io.File;

/**
 * Represents a directory that can be used for caching.
 *
 * <p>By default, a shared lock is held on this cache by this process, to prevent it being removed or rebuilt by another process