public void writeString(CharSequence value) {
        if (value == null) {
            throw new IllegalArgumentException("Cannot encode a null string.");
        }
        writeNullableString(value);
    }

    @Override
    public void writeNullableString(@Nullable CharSequence value) {
        if (value == null) {
            output.writeInt(-1);
            return;
        } else {
            if (strings == null) {

    public String read(Decoder decoder) throws Exception {
        return decoder.readNullableString();
    }

    @Override
    public void write(Encoder encoder, String value) throws Exception {
        encoder.writeNullableString(value);
    }

        }

        @Override
        public void write(Encoder encoder, ClassAnalysis value) throws Exception {
            encoder.writeString(value.getClassName());
            encoder.writeNullableString(value.getDependencyToAllReason());
            stringSetSerializer.write(encoder, value.getPrivateClassDependencies());
            stringSetSerializer.write(encoder, value.getAccessibleClassDependencies());

        try {
            encoder.writeSmallLong(value.getResultId());
            reasonSerializer.write(encoder, value.getSelectionReason());
            encoder.writeNullableString(value.getRepositoryName());
            componentDetailsSerializer.writeComponentDetails(value.getResolveState(), includeAllSelectableVariantResults, encoder);

        if (value == null) {
            writeBoolean(false);
        } else {
            writeBoolean(true);
            writeSmallInt(value);
        }
    }

    @Override
    public void writeNullableString(@Nullable CharSequence value) throws IOException {
        if (value == null) {
            writeBoolean(false);
        } else {
            writeBoolean(true);
            writeString(value.toString());
        }

        }

        @Override
        public void write(Encoder encoder, DefaultDaemonContext context) throws Exception {
            encoder.writeNullableString(context.uid);
            encoder.writeString(context.javaHome.getPath());
            encoder.writeSmallInt(context.javaVersion.asInt());
            encoder.writeString(context.daemonRegistryDir.getPath());

        if (value == null) {
            throw new IllegalArgumentException("Cannot encode a null string.");
        }
        output.writeString(value);
    }

    @Override
    public void writeNullableString(@Nullable CharSequence value) {
        output.writeString(value);
    }

    @Override
    public void encodeChunked(EncodeAction<Encoder> writeAction) throws Exception {
        if (nested == null) {

    private val fileSystemOperations: FileSystemOperations
) : Codec<DefaultCopySpec> {

    override suspend fun WriteContext.encode(value: DefaultCopySpec) {
        encodePreservingIdentityOf(value) {
            writeNullableString(value.destinationDir?.path)
            write(value.sourceRootsForThisSpec)
            write(value.patterns)
            writeEnum(value.duplicatesStrategyForThisSpec)
            writeBoolean(value.includeEmptyDirs)

    /**
     * Writes a non-null string value.
     */
    void writeString(CharSequence value) throws IOException;

    /**
     * Writes a nullable string value.
     */
    void writeNullableString(@Nullable CharSequence value) throws IOException;

    interface EncodeAction<T> {
        void write(T target) throws Exception;
    }

            encoder.writeBoolean(value.status != null);
            if (value.status != null) {
                encoder.writeByte((byte) value.status.ordinal());
            }

            encoder.writeNullableString(value.reason);
        }
    }