}

// NewReader creates a new [Reader] reading the given reader.
// If r does not also implement [io.ByteReader],
// the decompressor may read more data than necessary from r.
//
// It is the caller's responsibility to call Close on the [Reader] when done.
//
// The [Reader.Header] fields will be valid in the [Reader] returned.
func NewReader(r io.Reader) (*Reader, error) {
	z := new(Reader)
	if err := z.Reset(r); err != nil {

  } else {
    reader_.reset(new TensorSliceReader(filename));
    if (!reader_->status().ok()) {
      tsl::Set_TF_Status_from_Status(status, reader_->status());
      return;
    }
    var_to_shape_map_.reset(
        new TensorSliceReader::VarToShapeMap(reader_->GetVariableToShapeMap()));
    var_to_data_type_map_.reset(new TensorSliceReader::VarToDataTypeMap(
        reader_->GetVariableToDataTypeMap()));
  }
}

        Thread thread = Thread.currentThread();
        TestOutputStore.Reader reader = readers.get(thread);
        if (reader == null) {
            reader = outputStore.reader();
            readers.put(thread, reader);
        }
        return reader;
    }

    @Override
    public void close() throws IOException {
        CompositeStoppable.stoppable(readers.values()).stop();
    }

    protected List<WorkspaceReader> readers;
    protected WorkspaceRepository repository;

    /**
     * Creates a new workspace reader by chaining the specified readers.
     *
     * @param readers The readers to chain must not be {@code null}.
     */
    public MavenChainedWorkspaceReader(WorkspaceReader... readers) {
        setReaders(Arrays.asList(readers));
    }

    @Override

	w           Mutex        // held if there are pending writers
	writerSem   uint32       // semaphore for writers to wait for completing readers
	readerSem   uint32       // semaphore for readers to wait for completing writers
	readerCount atomic.Int32 // number of pending readers
	readerWait  atomic.Int32 // number of departing readers
}

const rwmutexMaxReaders = 1 << 30

// Happens-before relationships are indicated to the race detector via:

	"internal/trace/event/go122"
	"internal/trace/internal/oldtrace"
	"internal/trace/version"
)

// Reader reads a byte stream, validates it, and produces trace events.
type Reader struct {
	r           *bufio.Reader
	lastTs      Time
	gen         *generation
	spill       *spilledBatch
	spillErr    error // error from reading spill
	frontier    []*batchCursor
	cpuSamples  []cpuSample
	order       ordering
	emittedSync bool

// Package iotest implements Readers and Writers useful mainly for testing.
package iotest

import (
	"bytes"
	"errors"
	"fmt"
	"io"
)

// OneByteReader returns a Reader that implements
// each non-empty Read by reading one byte from r.
func OneByteReader(r io.Reader) io.Reader { return &oneByteReader{r} }

type oneByteReader struct {
	r io.Reader
}

// NewMonitoredReader returns reference to a monitored reader that throttles reads to configured bandwidth for the
// bucket.
func NewMonitoredReader(ctx context.Context, m *Monitor, r io.Reader, opts *MonitorReaderOptions) *MonitoredReader {
	reader := MonitoredReader{
		r:        r,
		throttle: m.throttle(opts.BucketOptions),
		m:        m,
		opts:     opts,
		ctx:      ctx,
	}
	reader.m.init(opts.BucketOptions)
	return &reader

Thai Nguyen <******@****.***> 1709597042 -0800

 * The caller is responsible for closing {@code InputStream} and {@code Reader} arguments.
 */
public class XmlNodeBuilder {
    private static final boolean DEFAULT_TRIM = true;

    public static XmlNodeImpl build(Reader reader) throws XmlPullParserException, IOException {
        return build(reader, (InputLocationBuilder) null);
    }

    /**
     * @param reader the reader
     * @param locationBuilder the builder
     * @since 3.2.0