*/

package org.gradle.workers;

import javax.inject.Inject;

/**
 * Represents the implementation of a unit of work to be used when submitting work to the
 * {@link WorkerExecutor}.
 *
 * <p>
 *     A work action implementation is an abstract class implementing the {@link #execute()} method.
 *     A minimal implementation may look like this:
 * </p>
 *
 * <pre class='autoTested'>

     */
    ClassLoader getIsolatedSystemClassLoader();

    /**
     * Creates a ClassLoader implementation which has only the classes from the specified URIs and the Java API visible.
     */
    ClassLoader createIsolatedClassLoader(String name, ClassPath classPath);

    /**

    public String getHashCode() {
        return hashCode.toString();
    }

    // TODO Provide default implementation
    // TODO Deprecate and move this to BuildCacheKeyInternal
    @Override
    public byte[] toByteArray() {
        return hashCode.toByteArray();
    }

    // TODO Provide default implementation
    @Override
    @Deprecated
    @SuppressWarnings("InlineMeSuggester")
    public String getDisplayName() {

    /**
     * Creates a decoder that reads from the given input stream. Note that the implementation may perform buffering, and may consume any or all of the
     * content from the given input stream.
     */
    Decoder newDecoder(InputStream inputStream);

    /**
     * Creates an encoder that writes the given output stream. Note that the implementation may perform buffering.
     */
    FlushableEncoder newEncoder(OutputStream outputStream);

final class Platform {

  /** Returns the platform preferred implementation of a map based on a hash table. */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return Maps.newHashMapWithExpectedSize(expectedSize);
  }

  /**
   * Returns the platform preferred implementation of an insertion ordered map based on a hash
   * table.
   */

 * limitations under the License.
 */
package org.gradle.internal.serialize;

import java.io.EOFException;

public interface Serializer<T> {
    /**
     * Reads the next object from the given stream. The implementation must not perform any buffering, so that it reads only those bytes from the input stream that are
     * required to deserialize the next object.
     *

// tag::sample[]
// The following types can appear anywhere in the code
// but say nothing about API or implementation usage
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

 *   void generateScript(JavaAppStartScriptGenerationDetails details, Writer destination) {
 *     // implementation
 *   }
 * }
 *
 * class CustomWindowsStartScriptGenerator implements ScriptGenerator {
 *   void generateScript(JavaAppStartScriptGenerationDetails details, Writer destination) {
 *     // implementation
 *   }
 * }
 * </pre>
 * <p>

        @Override
        public ValueSnapshot implementationValue(String implementationClassIdentifier, Object implementation) {
            return ImplementationSnapshot.of(
                implementationClassIdentifier,
                implementation,
                classLoaderHasher.getClassLoaderHash(implementation.getClass().getClassLoader()));
        }

        @Override
        public ValueSnapshot fileValue(File value) {

    return delegate().descendingMultiset();
  }

  /**
   * A skeleton implementation of a descending multiset view. Normally, {@link
   * #descendingMultiset()} will not reflect any changes you make to the behavior of methods such as
   * {@link #add(Object)} or {@link #pollFirstEntry}. This skeleton implementation correctly
   * delegates each of its operations to the appropriate methods of this {@code