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

import java.util.ArrayList;
import java.util.List;

public class SerializedPayloadSerializer implements Serializer<SerializedPayload> {
    private final Serializer<Object> javaSerializer = new DefaultSerializer<Object>();

    @Override
    public void write(Encoder encoder, SerializedPayload value) throws Exception {

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.writeBoolean(event.isFailing());
    }

            store.write(encoder -> {
                encoder.writeByte(COMPONENT);
                componentResultSerializer.write(encoder, component);
            });
        }
    }

    @Override
    public void visitSelector(final DependencyGraphSelector selector) {
        store.write(encoder -> {
            encoder.writeByte(SELECTOR);
            encoder.writeSmallLong(selector.getResultId());

				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *SiteResyncStatus) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 6
	// write "v"
	err = en.Append(0x86, 0xa1, 0x76)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Version)

            values.add(entrySerializer.read(decoder));
        }
        return values;
    }

    @Override
    public void write(Encoder encoder, C value) throws Exception {
        encoder.writeInt(value.size());
        for (T t : value) {
            entrySerializer.write(encoder, t);
        }
    }

				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *RenameDataInlineHandlerParams) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 1
	// write "p"
	err = en.Append(0x81, 0xa1, 0x70)
	if err != nil {
		return
	}
	err = z.RenameDataHandlerParams.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "RenameDataHandlerParams")

        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

            def missing = decoder.readBoolean()
            return cachedItem(file, missing)
        }

        @Override
        void write(Encoder encoder, CachedItem value) throws Exception {
            encoder.writeString(value.cachedFile?.absolutePath ?: "")
            encoder.writeBoolean(value.missing)
        }
    }

	return &watchEmbeddedEncoder{
		encoder:      encoder,
		ctx:          ctx,
		target:       target,
		tableOptions: tableOptions,
		scope:        scope,
	}
}

// Encode implements runtime.Encoder interface.
func (e *watchEmbeddedEncoder) Encode(obj runtime.Object, w io.Writer) error {