this.stringInterner = stringInterner;
    }

    @Override
    public String read(Decoder decoder) throws Exception {
        return stringInterner.intern(decoder.readString());
    }

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

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

import java.io.Closeable;
import java.io.IOException;

public interface BinaryStore {
    void write(WriteAction write);

    //done writing data, release any resources
    BinaryData done();

    interface WriteAction {
        void write(Encoder encoder) throws IOException;
    }

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

import java.io.IOException;

public interface AttributeContainerSerializer extends Serializer<AttributeContainer> {
    @Override
    ImmutableAttributes read(Decoder decoder) throws IOException;

    @Override
    void write(Encoder encoder, AttributeContainer container) throws IOException;

    @Override
    void encodeTo(OutputStream outputStream, Closure<Encoder> closure) {
        def encoder = new OutputStreamBackedEncoder(outputStream)
        closure.call(encoder)
    }

    @Override
    void decodeFrom(InputStream inputStream, Closure<Decoder> closure) {
        def decoder = new InputStreamBackedDecoder(inputStream)
        closure.call(decoder)
    }

	return
}

// NewDecoder constructs a new ascii85 stream decoder.
func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} }

type decoder struct {
	err     error
	readErr error
	r       io.Reader
	buf     [1024]byte // leftover input
	nbuf    int
	out     []byte // leftover decoded output
	outbuf  [1024]byte
}

func (d *decoder) Read(p []byte) (n int, err error) {
	if len(p) == 0 {

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

public interface ComponentDetailsSerializer {
    void writeComponentDetails(ComponentGraphResolveState component, boolean requireAllVariants, Encoder encoder) throws Exception;

    void readComponentDetails(Decoder decoder, ResolvedComponentVisitor visitor) throws Exception;

				argidx = 1 // func([]byte, interface{})
			}
		} else if fn.Name() == "Decode" && recv != nil {
			// (*"encoding/json".Decoder).Decode
			// (* "encoding/gob".Decoder).Decode
			// (* "encoding/xml".Decoder).Decode
			_, named := typesinternal.ReceiverNamed(recv)
			if tname := named.Obj(); tname.Name() == "Decoder" {
				switch tname.Pkg().Path() {
				case "encoding/json", "encoding/xml", "encoding/gob":

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

public class ReadStdInEventSerializer implements Serializer<ReadStdInEvent> {

    @Override
    public void write(Encoder encoder, ReadStdInEvent event) throws Exception {
    }

    @Override
    public ReadStdInEvent read(Decoder decoder) throws Exception {

import org.gradle.internal.logging.events.UserInputRequestEvent;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

public class UserInputRequestEventSerializer implements Serializer<UserInputRequestEvent> {

    @Override
    public void write(Encoder encoder, UserInputRequestEvent event) throws Exception {
    }

    @Override

     * @throws EOFException When the next object cannot be fully read due to reaching the end of stream.
     */
    T read(Decoder decoder) throws EOFException, Exception;

    /**
     * Writes the given object to the given stream. The implementation must not perform any buffering.
     */
    void write(Encoder encoder, T value) throws Exception;