this.interner = interner;
        }

        @Override
        public ClassAnalysis read(Decoder decoder) throws Exception {
            String className = interner.intern(decoder.readString());
            String dependencyToAllReason = decoder.readNullableString();
            Set<String> privateClasses = stringSetSerializer.read(decoder);
            Set<String> accessibleClasses = stringSetSerializer.read(decoder);

    }

    @Override
    public boolean readBoolean() throws EOFException, IOException {
        return inputStream.readBoolean();
    }

    @Override
    public String readString() throws EOFException, IOException {
        return inputStream.readUTF();
    }

    @Override
    public byte readByte() throws IOException {
        return (byte) (inputStream.readByte() & 0xff);
    }

	if !isIdent(c) {
		r.syntaxError()
		return
	}
	for isIdent(r.peekByte(false)) {
		r.peek = 0
	}
}

// readString reads a quoted string literal from the input.
// If an identifier is not present, readString records a syntax error.
func (r *importReader) readString() {
	switch r.nextByte(true) {
	case '`':
		for r.err == nil {
			if r.nextByte(false) == '`' {
				break
			}
			if r.eof {

    }
}


fun Decoder.readStrings(): List<String> =
    readCollectionInto({ size -> ArrayList(size) }) {
        readString()
    }


fun Decoder.readStringsSet(): Set<String> =
    readCollectionInto({ size -> LinkedHashSet(size) }) {
        readString()
    }


inline fun <T> Encoder.writeCollection(collection: Collection<T>, writeElement: (T) -> Unit) {

        withGradleIsolate(rootBuild.gradle, userTypesCodec) {
            val identityPath = Path.path(readString())
            val hasProjects = readBoolean()
            if (hasProjects) {
                val rootProjectName = readString()
                val projects: List<ProjectWithNoWork> = readList().uncheckedCast()
                BuildWithNoWork(identityPath, rootProjectName, projects)

            )
          } else if (gzippedLength != null) {
            logger.log("--> END ${request.method} (${buffer.size}-byte, $gzippedLength-gzipped-byte body)")
          } else {
            logger.log(buffer.readString(charset))
            logger.log("--> END ${request.method} (${requestBody.contentLength()}-byte body)")
          }
        }
      }

      val startNs = System.nanoTime()
      val response: Response

            val duplicatesStrategy = readEnum<DuplicatesStrategy>()
            val includeEmptyDirs = readBoolean()
            val isCaseSensitive = readBoolean()
            val filteringCharset = readString()
            val dirMode = readNullableSmallInt()
            val fileMode = readNullableSmallInt()
            val actions = readList().uncheckedCast<List<Action<FileCopyDetails>>>()

        HierarchicalNameSerializer nameSerializer = hierarchicalNameSerializerSupplier.get();
        byte b = decoder.readByte();
        if (b == 0) {
            return DependentsSet.dependencyToAll(decoder.readString());
        }

        ImmutableSet.Builder<String> privateBuilder = ImmutableSet.builder();
        int count = decoder.readSmallInt();
        for (int i = 0; i < count; i++) {

func TestLatin1(t *testing.T) {
	latin1 := []byte{0xc4, 'u', 0xdf, 'e', 'r', 'u', 'n', 'g', 0}
	utf8 := "Äußerung"
	z := Reader{r: bufio.NewReader(bytes.NewReader(latin1))}
	s, err := z.readString()
	if err != nil {
		t.Fatalf("readString: %v", err)
	}
	if s != utf8 {
		t.Fatalf("read latin-1: got %q, want %q", s, utf8)
	}

	buf := bytes.NewBuffer(make([]byte, 0, len(latin1)))
	c := Writer{w: buf}

        return name;
    }

    private String readFirstOccurrenceOfName(Decoder decoder) throws IOException {
        byte separator = decoder.readByte();
        if (separator == 0) {
            return decoder.readString();
        } else {
            String parent = readName(decoder);
            String child = readName(decoder);
            return parent + (char) (separator & 0xFF) + child;
        }
    }