public ModuleDescriptorHashModuleSource decode(Decoder decoder) throws IOException {
        return new ModuleDescriptorHashModuleSource(
            HashCode.fromBytes(decoder.readBinary()),
            decoder.readBoolean()
        );
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        return o != null && getClass() == o.getClass();
    }

    }

    @Override
    public void readSelectedVariant(Decoder decoder, ResolvedComponentVisitor visitor) throws Exception {
        long nodeId = decoder.readSmallLong();
        if (decoder.readBoolean()) {
            readVariantData(decoder, visitor, nodeId);
        } else {
            readVariantReference(decoder, visitor, nodeId);
        }
    }

            return input.readDouble();
        } catch (KryoException e) {
            throw maybeEndOfStream(e);
        }
    }

    @Override
    public boolean readBoolean() throws EOFException {
        try {
            return input.readBoolean();
        } catch (KryoException e) {
            throw maybeEndOfStream(e);
        }
    }

    @Override
    public String readString() throws EOFException {

        String message = decoder.readNullableString();
        Throwable throwable = throwableSerializer.read(decoder);
        OperationIdentifier buildOperationId = decoder.readBoolean() ? new OperationIdentifier(decoder.readSmallLong()) : null;
        return new LogEvent(timestamp, category, logLevel, message, throwable, buildOperationId);
    }

        OperationIdentifier id = new OperationIdentifier(decoder.readSmallLong());
        long timestamp = decoder.readLong();
        String status = decoder.readString();
        boolean failed = decoder.readBoolean();
        return new ProgressCompleteEvent(id, timestamp, status, failed);
    }

        writeFile(it.first)
        writeFile(it.second)
    }
}


internal
fun Decoder.readClassPath(): ClassPath {
    val isTransformed = readBoolean()
    return if (isTransformed) {
        readTransformedClassPath()
    } else {
        readDefaultClassPath()
    }
}


internal
fun Decoder.readDefaultClassPath(): ClassPath {

            encoder.writeBoolean(true)
            encoder.writeBoolean(false)
        }
        decode(bytes) { Decoder decoder ->
            assert decoder.readBoolean()
            assert !decoder.readBoolean()
        }
    }

    def "decode fails when boolean cannot be fully read"() {
        given:
        def bytes = truncate { Encoder encoder ->
            encoder.writeBoolean(true)

            val contents = codec.run { decodeContents() }
            val fileCollection = fileCollectionFactory.configurableFiles()
            fileCollection.from(contents)
            if (readBoolean()) {
                fileCollection.finalizeValue()
            }
            isolate.identities.putInstance(id, fileCollection)
            fileCollection
        }
    }

        long timestamp = decoder.readLong();
        String category = decoder.readString();
        LogLevel logLevel = logLevelSerializer.read(decoder);
        OperationIdentifier buildOperationId = decoder.readBoolean() ? new OperationIdentifier(decoder.readSmallLong()) : null;
        List<StyledTextOutputEvent.Span> spans = spanSerializer.read(decoder);

        dataOutput.writeBoolean(!state.dirty);
    }

    @Override
    public LockState read(DataInput dataInput) throws IOException {
        return new DirtyFlagLockState(!dataInput.readBoolean());
    }

    private static class DirtyFlagLockState implements LockState {
        private final boolean dirty;

        private DirtyFlagLockState(boolean dirty) {
            this.dirty = dirty;
        }