return new JvmMemoryStatusSnapshot(maxMemory, committedMemory);
        }

        @Override
        public void write(Encoder encoder, JvmMemoryStatus jvmMemoryStatus) throws Exception {
            encoder.writeLong(jvmMemoryStatus.getCommittedMemory());
            encoder.writeLong(jvmMemoryStatus.getMaxMemory());
        }
    }

	// "Hello, world!"
}

func ExampleNewEncoder() {
	input := []byte("foo\x00bar")
	encoder := base32.NewEncoder(base32.StdEncoding, os.Stdout)
	encoder.Write(input)
	// Must close the encoder when finished to flush any partial blocks.
	// If you comment out the following line, the last partial block "r"
	// won't be encoded.
	encoder.Close()
	// Output:
	// MZXW6ADCMFZA====

        }

        @Override
        public void write(Encoder encoder, CachedExternalResource value) throws Exception {
            encoder.writeBoolean(value.getCachedFile() != null);
            if (value.getCachedFile() != null) {
                encoder.writeString(relativizeAndNormalizeFilePath(value.getCachedFile()));
            }
            encoder.writeLong(value.getCachedAt());

            result.add(decoder.readInt());
        }
        return result;
    }

    @Override
    public void write(Encoder encoder, IntSet value) throws Exception {
        encoder.writeInt(value.size());
        IntIterator iterator = value.iterator();
        while(iterator.hasNext()) {
            encoder.writeInt(iterator.nextInt());
        }
    }

        def encoder = Mock(Encoder)
        def value = Mock(CachedExternalResource)
        def fileName = "file.txt"

        when:
        serializer.write(encoder, value)

        then:
        _ * value.getCachedFile() >> commonPath.resolve(fileName).toFile()

        1 * encoder.writeString(fileName)
    }

            this.moduleIdentifierFactory = moduleIdentifierFactory;
        }

        @Override
        public void write(Encoder encoder, ModuleAtRepositoryKey value) throws Exception {
            encoder.writeString(value.repositoryId);
            encoder.writeString(value.moduleId.getGroup());
            encoder.writeString(value.moduleId.getName());
        }

        @Override

-- input --
Package gob manages streams of gobs - binary values exchanged between an
Encoder (transmitter) and a Decoder (receiver). A typical use is
transporting arguments and results of remote procedure calls (RPCs) such as
those provided by package "net/rpc".

The implementation compiles a custom codec for each data type in the stream
and is most efficient when a single Encoder is used to transmit a stream of
values, amortizing the cost of compilation.

        this.interner = interner;
    }

    public PreviousCompilationData readPreviousCompilationData(File source) {
        try (KryoBackedDecoder encoder = new KryoBackedDecoder(new FileInputStream(source))) {
            return new PreviousCompilationData.Serializer(interner).read(encoder);
        } catch (Exception e) {
            throw new IllegalStateException("Could not read previous compilation result.", e);
        }
    }

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

public class UserInputResumeEventSerializer implements Serializer<UserInputResumeEvent> {

    @Override
    public void write(Encoder encoder, UserInputResumeEvent event) throws Exception {
        encoder.writeLong(event.getTimestamp());
    }

    @Override

        decoder.readBytes(hash);
        return HashCode.fromBytes(hash);
    }

    @Override
    public void write(Encoder encoder, HashCode value) throws IOException {
        byte[] hash = value.toByteArray();
        encoder.writeByte((byte) hash.length);
        encoder.writeBytes(hash);
    }