Map<String, ModuleConfigurationMetadata> configurations = Maps.newHashMapWithExpectedSize(configurationsCount);

        for (int i = 0; i < configurationsCount; i++) {
            String configurationName = decoder.readString();
            boolean transitive = true;
            boolean visible = true;
            ImmutableSet<String> hierarchy = ImmutableSet.of(configurationName);
            ImmutableList<ExcludeMetadata> excludes;

        encoder.writeString(value.getQuestion());
    }

    @Override
    public YesNoQuestionPromptEvent read(Decoder decoder) throws Exception {
        return new YesNoQuestionPromptEvent(decoder.readLong(), decoder.readString());
    }

			if err != nil {
				err = msgp.WrapError(err, "DiskIndex")
				return
			}
		case "Path":
			z.Path, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Path")
				return
			}
		case "Endpoint":
			z.Endpoint, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Endpoint")
				return
			}
		case "Started":
			z.Started, err = dc.ReadTime()

func (z *Reader) Multistream(ok bool) {
	z.multistream = ok
}

// readString reads a NUL-terminated string from z.r.
// It treats the bytes read as being encoded as ISO 8859-1 (Latin-1) and
// will output a string encoded using UTF-8.
// This method always updates z.digest with the data read.
func (z *Reader) readString() (string, error) {
	var err error
	needConv := false
	for i := 0; ; i++ {

        PublishArtifactLocalArtifactMetadata delegate = publishArtifactLocalArtifactMetadataSerializer.read(decoder);
        File file = new File(decoder.readString());
        return new CompositeProjectComponentArtifactMetadata(componentIdentifier, delegate, file);
    }

    @Override

        def decoder = Mock(Decoder)
        def fileName = "file.txt"

        when:
        def result = serializer.read(decoder)

        then:
        1 * decoder.readBoolean() >> true
        1 * decoder.readString() >> fileName
        1 * decoder.readLong() >> 42L
        1 * decoder.readBoolean() >> false

        result.getCachedFile() == commonPath.resolve(fileName).toFile()
    }

		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ID":
			z.ID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "User":
			z.User, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "User")
				return
			}
		case "Started":
			z.Started, err = dc.ReadTime()

        }
    }

    @Override
    public LogEvent read(Decoder decoder) throws Exception {
        long timestamp = decoder.readLong();
        String category = decoder.readString();
        LogLevel logLevel = logLevelSerializer.read(decoder);
        String message = decoder.readNullableString();
        Throwable throwable = throwableSerializer.read(decoder);

	}
	defer fd.Close()
	br := bufio.NewReader(fd)

	file, err := open(filename)
	if file == nil {
		t.Fatal(err)
	}
	defer file.close()

	lineno := 1
	byteno := 0
	for {
		bline, berr := br.ReadString('\n')
		if n := len(bline); n > 0 {
			bline = bline[0 : n-1]
		}
		line, ok := file.readLine()
		if (berr != nil) != !ok || bline != line {

    private UniqueIdSerializer() {
    }

    @Override
    public UniqueId read(Decoder decoder) throws Exception {
        String string = decoder.readString();
        return UniqueId.from(string);
    }

    @Override
    public void write(Encoder encoder, UniqueId value) throws Exception {
        encoder.writeString(value.asString());
    }