import org.gradle.work.DisableCachingByDefault
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Properties
import java.util.TimeZone


@DisableCachingByDefault(because = "Not worth caching")
abstract class BuildReceipt : DefaultTask() {
    companion object {
        private
        val timestampFormat = newSimpleDateFormatUTC("yyyyMMddHHmmssZ")

        private

# ADR-0002 - Avoid using Java serialization

## Date

2012-12-01

## Context

In Gradle we often need to serialize in-memory objects for caching, or to transmit them across process barriers, etc.
Java serialization is one way to implement this, however, despite its simplicity of implementation, it has several drawbacks:

- **Performance:**
Java's built-in serialization mechanism is often slower compared to other serialization solutions.

import org.gradle.work.DisableCachingByDefault
import java.io.File
import javax.inject.Inject

private const val VOLUME_NAME = "AndroidStudioForGradle"

@DisableCachingByDefault(because = "Not worth caching")
abstract class ExtractAndroidStudioTask @Inject constructor(
    private val execOps: ExecOperations,
    private val fsOps: FileSystemOperations,
    private val fileOps: FileOperations
) : DefaultTask() {

- **Configuration**: Allows the build structure and work, such as tasks, to be specified. This includes the project model, the DSL and so on.
- **Execution**: Runs the work efficiently. This includes scheduling, execution, caching and so on.

#### Software development platform

This is a general purpose platform that builds on the core automation platform to add support for the automation of software development.

- **Thread Safety**: Components support concurrent access
- **DFS Support**: Distributed File System resolution
- **Streaming Operations**: Efficient directory listings and file operations
- **Buffer Caching**: Optimized buffer management
- **DCE/RPC Protocol**: Support for advanced operations

## Quick Start

### Basic Usage

```java
import jcifs.CIFSContext;
import jcifs.context.SingletonContext;

 * <li>Download and Cache: If Maven finds the artifact in a remote repository, it downloads it and stores it in the local repository for future use.</li>
 * </ol>
 * <p>By caching artifacts in the local repository, Maven minimizes the need to repeatedly download the same artifacts, thus optimizing the build process.</p>
 *
 * <h2>Repository Configuration</h2>
 *

    steps:
    - name: Checkout repository
      uses: actions/checkout@v6
      # Checkout must run before the caching key is computed using the `hashFiles` method

    - name: Cache Gradle Modules
      uses: actions/cache@v5
      with:
        path: |
          ~/.gradle/caches/modules-2/
          ~/.gradle/caches/build-cache-1/

  // Create a second ClassLoader and use it to get a second version of the TestEnum class.
  // Run Enums.getIfPresent on that other TestEnum and then return a WeakReference containing the
  // new ClassLoader. If Enums.getIfPresent does caching that prevents the shadow TestEnum
  // (and therefore its ClassLoader) from being unloaded, then this WeakReference will never be
  // cleared.
  @J2ktIncompatible

            return null;
        }
    }

    /**
     * Implementation of {@link ModelSource} that extends {@link PathSource} with model-specific
     * functionality. This implementation uses request-scoped caching ({@link CacheRetention#REQUEST_SCOPED})
     * since it represents a POM file that is actively being built and may change during the build process.
     * <p>
     * The request-scoped retention policy ensures that:

- **core-configuration**: Allows the build structure and work, such as tasks, to be specified. This includes the project model, the DSL and so on.
- **core-execution**: Runs the work efficiently. This includes scheduling, execution, caching and so on.

### Software development platform

This is a general purpose platform that builds on the core automation platform to add support for the automation of software development.