@Override
        public FileInfo read(Decoder decoder) throws Exception {
            HashCode hash = hashCodeSerializer.read(decoder);
            long timestamp = decoder.readLong();
            long length = decoder.readLong();
            return new FileInfo(hash, length, timestamp);
        }

        @Override
        public void write(Encoder encoder, FileInfo value) throws Exception {

            return null;
        }
        try {
            InputStreamBackedDecoder decoder = new InputStreamBackedDecoder(new BufferedInputStream(new FileInputStream(cacheFile)));
            try {
                return serializer.read(decoder);
            } finally {
                decoder.close();
            }
        } catch (Exception e) {

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

public interface SelectedVariantSerializer {
    void writeVariantResult(ResolvedGraphVariant variant, Encoder encoder) throws Exception;

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

	if err != nil {
		t.Fatal(err)
	}
	uncastDstObj2, err := runtime.Decode(decoder, srcObj2Bytes)
	if err != nil {
		t.Fatal(err)
	}

	// clear typemeta
	uncastDstObj1.(*FakeV1Obj).TypeMeta = metav1.TypeMeta{}
	uncastDstObj2.(*FakeV2DifferentObj).TypeMeta = metav1.TypeMeta{}

	if !equality.Semantic.DeepEqual(srcObj1, uncastDstObj1) {
		t.Fatal(cmp.Diff(srcObj1, uncastDstObj1))
	}

		buf := make([]byte, MaxEncodedLen(len(p.decoded)))
		n := Encode(buf, []byte(p.decoded))
		buf = buf[0:n]
		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(string(buf)), strip85(p.encoded))
	}
}

func TestEncoder(t *testing.T) {
	for _, p := range pairs {
		bb := &strings.Builder{}
		encoder := NewEncoder(bb)
		encoder.Write([]byte(p.decoded))
		encoder.Close()

import org.gradle.internal.serialize.Decoder;

import java.io.Closeable;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Note that this decoder uses buffering, so will attempt to read beyond the end of the encoded data. This means you should use this type only when this decoder will be used to decode the entire
 * stream.
 */

    }

    @Override
    public T read(Decoder decoder) throws Exception {
        try {
            return Cast.uncheckedNonnullCast(new ClassLoaderObjectInputStream(decoder.getInputStream(), classLoader).readObject());
        } catch (StreamCorruptedException e) {
            return null;
        }
    }

    @Override
    public void write(Encoder encoder, T value) throws IOException {

) : Closeable {

    private
    val valuesStore by lazy {
        val writer = ValueStore.Writer<V> { encoder, value ->
            write(encoder, value)
        }
        val reader = ValueStore.Reader { decoder ->
            read(decoder)
        }
        store.createValueStore(stateType, writer, reader)
    }

    private

 */
public interface StatefulSerializer<T> {
    /**
     * Should not perform any buffering
     */
    ObjectReader<T> newReader(Decoder decoder);

    /**
     * Should not perform any buffering
     */
    ObjectWriter<T> newWriter(Encoder encoder);

// license that can be found in the LICENSE file.

// This file is a simple protocol buffer encoder and decoder.
//
// A protocol message must implement the message interface:
//   decoder() []decoder
//   encode(*buffer)
//
// The decode method returns a slice indexed by field number that gives the
// function to decode that field.
// The encode method encodes its receiver into the given buffer.
//