}

    @Override
    public ImmutableAttributes read(Decoder decoder) throws IOException {
        ImmutableAttributes attributes = ImmutableAttributes.EMPTY;
        int count = decoder.readSmallInt();
        for (int i = 0; i < count; i++) {
            String name = decoder.readString();
            byte type = decoder.readByte();
            if (type == BOOLEAN_ATTRIBUTE) {

        encoder.writeString(event.getStatus());
        encoder.writeBoolean(event.isFailed());
    }

    @Override
    public ProgressCompleteEvent read(Decoder decoder) throws Exception {
        OperationIdentifier id = new OperationIdentifier(decoder.readSmallLong());
        long timestamp = decoder.readLong();
        String status = decoder.readString();
        boolean failed = decoder.readBoolean();

import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class ProgressEventSerializer implements Serializer<ProgressEvent> {
    @Override
    public void write(Encoder encoder, ProgressEvent event) throws Exception {
        encoder.writeSmallLong(event.getProgressOperationId().getId());
        encoder.writeString(event.getStatus());

        });
        encoder.writeSmallInt(0); // end of sources
    }

    private int assertValidId(int codecId) {
        assert codecId >= 0 : "Module source must have a strictly positive source id";
        return codecId;
    }

    @Override
    public ModuleSources read(Decoder decoder) throws IOException {
        MutableModuleSources sources = new MutableModuleSources();
        int codecId;

        when:
        serializer.write(encoder, spec)
        encoder.flush()

        and:
        def decoder = new KryoBackedDecoder(new ByteArrayInputStream(outputStream.toByteArray()))
        def decodedSpec = serializer.read(decoder)

        then:
        decodedSpec.implementationClassName == spec.implementationClassName

        String name = decoder.readString();
        String version = decoder.readNullableString();
        return new DefaultImmutableCapability(group, name, version);
    }

    @Override
    public void write(Encoder encoder, Capability value) throws IOException {
        encoder.writeString(value.getGroup());
        encoder.writeString(value.getName());
        encoder.writeNullableString(value.getVersion());
    }

    @Override
    public void write(Encoder encoder, TransformedComponentFileArtifactIdentifier value) throws Exception {
        componentIdentifierSerializer.write(encoder, value.getComponentIdentifier());
        encoder.writeString(value.getFileName());
        encoder.writeString(value.getOriginalFileName());
    }

    @Override
    public TransformedComponentFileArtifactIdentifier read(Decoder decoder) throws Exception {

    @Override
    public WorkerConfig read(Decoder decoder) throws IOException {
        LogLevel logLevel = LogLevel.values()[decoder.readSmallInt()];
        boolean shouldPublishJvmMemoryInfo = decoder.readBoolean();
        NativeServicesMode nativeServicesMode = NativeServicesMode.values()[decoder.readSmallInt()];
        String gradleUserHomeDirPath = decoder.readString();

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

import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.FlushableEncoder;

import java.io.InputStream;
import java.io.OutputStream;

public interface MessageSerializer {
    /**
     * 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

import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class UserInputResumeEventSerializer implements Serializer<UserInputResumeEvent> {

    @Override
    public void write(Encoder encoder, UserInputResumeEvent event) throws Exception {
        encoder.writeLong(event.getTimestamp());
    }

    @Override