*/

package org.gradle.internal.serialize.kryo;

import org.gradle.internal.serialize.*;

public class TypeSafeSerializer<T> implements StatefulSerializer<Object> {
    private final Class<T> type;
    private final StatefulSerializer<T> serializer;

    public TypeSafeSerializer(Class<T> type, StatefulSerializer<T> serializer) {
        this.type = type;
        this.serializer = serializer;
    }

    @Override

    private static final OperationIdentifier OPERATION_ID = new OperationIdentifier(1234L)

    ProgressStartEventSerializer serializer

    def setup() {
        serializer = new ProgressStartEventSerializer()
    }

    def "can serialize ProgressStartEvent messages"(BuildOperationCategory category) {
        given:

public class ExecutionSequencerTest extends TestCase {

  ExecutorService executor;

  private ExecutionSequencer serializer;
  private SettableFuture<@Nullable Void> firstFuture;
  private TestCallable firstCallable;

  @Override
  public void setUp() throws Exception {
    executor = Executors.newCachedThreadPool();
    serializer = ExecutionSequencer.create();
    firstFuture = SettableFuture.create();

    inline fun <reified T> bind(serializer: Serializer<T>) =
        bind(T::class.java, serializer)

    fun bind(type: KClass<*>, codec: Codec<*>) =
        bind(type.java, codec)

    fun bind(type: KClass<*>, serializer: Serializer<*>) =
        bind(type.java, serializer)

    fun bind(type: Class<*>, serializer: Serializer<*>) =
        bind(type, SerializerCodec(serializer))

import org.gradle.internal.hash.HashCode;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.HashCodeSerializer;
import org.gradle.internal.serialize.Serializer;

public class ImplementationSnapshotSerializer implements Serializer<ImplementationSnapshot> {

    private enum Impl implements Serializer<ImplementationSnapshot> {
        CLASS {
            @Override

class ClassSetAnalysisDataSerializerTest extends Specification {

    HashCode hash = TestHashCodes.hashCodeFrom(0)
    @Subject serializer = new ClassSetAnalysisData.Serializer({ new HierarchicalNameSerializer(new StringInterner())})

    def "serializes"() {
        def data = new ClassSetAnalysisData(["A": hash, "B": hash, "C": hash, "D": hash],

        when:
        def out = serialize(snapshots, serializer)

        then:
        assertEqualSnapshots(out, snapshots)
    }

    def "reads and writes directory snapshots"() {
        def snapshots =  new DirectorySnapshot("/home/lptr/dev", "dev", DIRECT, hashCodeFrom(1111), [])

        when:
        def out = serialize(snapshots, serializer)

        then:

    ProgressEventSerializer serializer = new ProgressEventSerializer()

    def "can serialize ProgressEvent messages"() {
        given:
        def event = new ProgressEvent(OPERATION_ID, "status", true)

        when:
        def result = serialize(event, serializer)

        then:
        result instanceof ProgressEvent

* Existing usages of Serializer outside of this infrastructure should be migrated to use it.
* Existing usages of Java serialization should be migrated to use it.
* It is ok for Serializer to be used as a replacement for Java serialization as a migration step.

    public static final Serializer<Long> LONG_SERIALIZER = new LongSerializer();
    public static final Serializer<Float> FLOAT_SERIALIZER = new FloatSerializer();
    public static final Serializer<Double> DOUBLE_SERIALIZER = new DoubleSerializer();
    public static final Serializer<File> FILE_SERIALIZER = new FileSerializer();