}

    @Nonnull
    default T read(@Nonnull Reader reader) throws XmlReaderException {
        return read(reader, true);
    }

    @Nonnull
    default T read(@Nonnull Reader reader, boolean strict) throws XmlReaderException {
        return read(XmlReaderRequest.builder().reader(reader).strict(strict).build());
    }

    @Nonnull

type recordTransform struct {
	reader io.Reader
	// recordDelimiter can be up to 2 characters.
	recordDelimiter []byte
	oneByte         []byte
	useOneByte      bool
}

func (rr *recordTransform) Read(p []byte) (n int, err error) {
	if rr.useOneByte {
		p[0] = rr.oneByte[0]
		rr.useOneByte = false
		n, err = rr.reader.Read(p[1:])
		n++
	} else {
		n, err = rr.reader.Read(p)
	}

	if err != nil {

    }

    /**
     * Reads text from the given {@link Reader}.
     * <p>
     * The {@link Reader} is not closed by this method.
     * </p>
     *
     * @param reader
     *            the character input stream to read from (must not be {@literal null})
     * @return the text read from the reader
     */
    public static String readText(final Reader reader) {
        assertArgumentNotNull("reader", reader);

    }

    /**
     * @param reader a reader object.
     * @param strict a strict object.
     * @return PersistedToolchains
     * @throws IOException IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     *         any.
     * @see XmlStreamReader
     */
    public PersistedToolchains read(Reader reader, boolean strict) throws IOException, XmlPullParserException {

      }

      override fun fromDer(reader: DerReader): Any? {
        if (isOptional && !reader.hasNext()) return optionalValue

        val peekedHeader =
          reader.peekHeader()
            ?: throw ProtocolException("expected a value at $reader")
        for ((_, adapter) in choices) {
          if (adapter.matches(peekedHeader)) {
            return adapter.fromDer(reader)
          }
        }

}

// where we keep old *Readers
var readMsgpReaderPool = bpool.Pool[*msgp.Reader]{New: func() *msgp.Reader { return &msgp.Reader{} }}

// mspNewReader returns a *Reader that reads from the provided reader.
// The reader will be buffered.
// Return with readMsgpReaderPoolPut when done.
func msgpNewReader(r io.Reader) *msgp.Reader {
	p := readMsgpReaderPool.Get()
	if p.R == nil {
		p.R = xbufio.NewReaderSize(r, 32<<10)

    }

    public Settings read(Reader reader, boolean strict) throws IOException, XmlPullParserException {
        try {
            return new Settings(delegate.read(reader, strict, null));
        } catch (XMLStreamException e) {
            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

    public Settings read(Reader reader) throws IOException, XmlPullParserException {
        try {

    }

    /**
     * Wraps exception handling for {@link Properties#load(Reader)}.
     * <p>
     * The input reader is not closed.
     * </p>
     *
     * @param props the property set (must not be {@literal null})
     * @param reader the input reader (must not be {@literal null})
     */
    public static void load(final Properties props, final Reader reader) {
        assertArgumentNotNull("props", props);

        // of
        // InputStream.read(byte[], int, int)
        // See https://github.com/google/guava/issues/3542
        Reader reader = new StringReader(cannotDecode);
        InputStream decodingStream = encoding.decodingStream(reader);
        try {
          ByteStreams.exhaust(decodingStream);
          fail("Expected DecodingException");
        } catch (DecodingException expected) {

// disconnectReader will ensure that no reads can take place on
// the upstream reader after close has been called.
type disconnectReader struct {
	r  io.Reader
	mu sync.Mutex
}

func (d *disconnectReader) Read(p []byte) (n int, err error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	if d.r != nil {
		return d.r.Read(p)
	}
	return 0, errors.New("reader closed")
}

func (d *disconnectReader) Close() error {