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

 * limitations under the License.
 */

package org.gradle.internal.serialize;

import java.io.Closeable;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;

public class InputStreamBackedDecoder extends AbstractDecoder implements Decoder, Closeable {
    private final DataInputStream inputStream;

    public InputStreamBackedDecoder(InputStream inputStream) {

import org.gradle.internal.snapshot.RegularFileSnapshot;
import org.gradle.internal.snapshot.SnapshotVisitResult;

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

public class DefaultOutputFilesRepository implements OutputFilesRepository, Closeable {

    private final PersistentCache cacheAccess;
    enum OutputKind {
        OUTPUT,
        PARENT_OF_OUTPUT
    }

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

import java.io.Closeable;
import java.util.List;

/**
 * Services to be shared across build sessions.
 * <p>
 * Generally, one regular Gradle invocation is conceptually a session.