*       block indefinitely or fail if the source creates an infinite stream.
 *   <li><b>Non-destructive:</b> A <i>destructive</i> stream will consume or otherwise alter the
 *       bytes of the source as they are read from it. A source that provides such streams will not
 *       be reusable, and operations that read from the stream (including {@link #size()}, in some

		panic("Failed to acquire read lock")
	}
	// fmt.Println("1st read lock acquired, waiting...")

	if !lrwm.GetRLock(ctx, "", "object1", time.Second) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("2nd read lock acquired, waiting...")

	go func() {
		time.Sleep(2 * time.Second)
		lrwm.RUnlock()
		// fmt.Println("1st read lock released, waiting...")
	}()

	go func() {

     */
    String defaultValue() default "";

    /**
     * Specifies whether the configuration property is read-only.
     *
     * @return true if the property is read-only, false otherwise
     */
    boolean readOnly() default false;

    /**
     * Property source, which determines when and where the property will be read from or set for consumption.

    @Nonnull
    public static XmlNode read(InputStream input, @Nullable InputLocationBuilder locationBuilder)
            throws XMLStreamException {
        return getService().doRead(input, locationBuilder);
    }

    /**
     * Reads an XML node from a reader.
     */
    @Nonnull
    public static XmlNode read(Reader reader) throws XMLStreamException {
        return read(reader, null);
    }

    /**

	// check not at EOF
	b.WriteString("abcdefghijklmnopqrstuvwxyz")

	// after unsuccessful read
	if n, err := b.Read(nil); n != 0 || err != nil {
		t.Fatalf("Read(nil) = %d,%v; want 0,nil", n, err)
	}
	if err := b.UnreadByte(); err == nil {
		t.Fatal("UnreadByte after Read(nil): got no error")
	}

	// after successful read
	if _, err := b.ReadBytes('m'); err != nil {
		t.Fatalf("ReadBytes: %v", err)
	}

//   - Exactly 0 bytes are read and EOF is hit.
//   - Exactly 1 block of zeros is read and EOF is hit.
//   - At least 2 blocks of zeros are read.
func (tr *Reader) readHeader() (*Header, *block, error) {
	// Two blocks of zero bytes marks the end of the archive.
	if _, err := io.ReadFull(tr.r, tr.blk[:]); err != nil {
		return nil, nil, err // EOF is okay here; exactly 0 bytes read
	}

	bufCount := 0
	for _, b := range buf {
		if len(b) > 0 {
			bufCount++
		}
	}
	return bufCount >= p.dataBlocks
}

// Read reads from readers in parallel. Returns p.dataBlocks number of bufs.
func (p *parallelReader) Read(dst [][]byte) ([][]byte, error) {
	newBuf := dst
	if len(dst) != len(p.readers) {
		newBuf = make([][]byte, len(p.readers))
	} else {
		for i := range newBuf {

        // Allocate buffer for read data
        ByteBuffer readBuffer = bufferManager.allocateBuffer(request.getLength());
        RdmaMemoryRegion readRegion = provider.registerMemory(readBuffer, 
            EnumSet.of(RdmaAccess.LOCAL_WRITE, RdmaAccess.REMOTE_WRITE));
        
        try {
            // Create SMB2 Read request with RDMA read channel info

		return false, fmt.Errorf("RUnlock attempted on a write locked entity: %s", args.Resources[0])
	}
	if locksHeld > ReadLock {
		l.lockMap[args.Resources[0]] = locksHeld - ReadLock // Remove one of the read locks held
	} else {
		delete(l.lockMap, args.Resources[0]) // Remove the (last) read lock
	}
	return reply, nil
}

        NameServicePacket.writeInt2(2, src, 6);
        NameServicePacket.writeInt2(3, src, 8);
        NameServicePacket.writeInt2(4, src, 10);

        int read = packet.readHeaderWireFormat(src, 0);
        assertEquals(NameServicePacket.HEADER_LENGTH, read);

        assertEquals(0x1234, packet.nameTrnId);
        assertTrue(packet.isResponse);
        assertEquals(NameServicePacket.QUERY, packet.opCode);