return
			}
		case "Writes":
			z.Writes, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Writes")
				return
			}
		case "Reads":
			z.Reads, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Reads")
				return
			}
		case "LockQueue":
			z.LockQueue, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "LockQueue")
				return
			}

    }

    /**
     * Reads up to b.length bytes of data from this input stream into an array of bytes.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /**

                _dst = _dst.deferred;
                final int _sidss = this.num_sids;
                _dst.enc_ndr_long(_sidss);
                final int _sidsi = _dst.index;
                _dst.advance(4 * _sidss);

                _dst = _dst.derive(_sidsi);
                for (int _i = 0; _i < _sidss; _i++) {
                    this.sids[_i].encode(_dst);
                }
            }
        }

	}
	return data
}

// ReadByte reads and returns the next byte from the buffer.
// If no byte is available, it returns error [io.EOF].
func (b *Buffer) ReadByte() (byte, error) {
	if b.empty() {
		// Buffer is empty, reset to recover space.
		b.Reset()
		return 0, io.EOF
	}
	c := b.buf[b.off]
	b.off++
	b.lastRead = opRead
	return c, nil
}

// ReadRune reads and returns the next UTF-8-encoded

                    extraSidAtts[i] = new PacSidAttributes(sid, attributes[i]);
                }
            }

            // ID for resource domain (used with relative IDs to get SIDs)
            SID resourceDomainId = null;
            if (resourceDomainIdPointer != 0) {
                resourceDomainId = pacStream.readSid();
            }

 */
@J2ktIncompatible
@GwtIncompatible
public final class CharStreams {

  // 2K chars (4K bytes)
  private static final int DEFAULT_BUF_SIZE = 0x800;

  /** Creates a new {@code CharBuffer} for buffering reads or writes. */
  static CharBuffer createBuffer() {
    return CharBuffer.allocate(DEFAULT_BUF_SIZE);
  }

  private CharStreams() {}

  /**

        // Decode to new instance (decode reads 36 bytes, encode writes 40)
        FileBasicInfo decoded = new FileBasicInfo();
        int decodedBytes = decoded.decode(buffer, 0, 36);

        // Verify encoding/decoding
        assertEquals(40, encodedBytes); // encode writes 40 bytes (includes padding)
        assertEquals(36, decodedBytes); // decode reads 36 bytes (no padding)

                _dst = _dst.deferred;
                final int _sidss = num_sids;
                _dst.enc_ndr_long(_sidss);
                final int _sidsi = _dst.index;
                _dst.advance(4 * _sidss);

                _dst = _dst.derive(_sidsi);
                for (int _i = 0; _i < _sidss; _i++) {
                    sids[_i].encode(_dst);
                }
            }
        }

     *
     * @return average read latency
     */
    public double getAverageReadLatencyMicros() {
        long reads = rdmaReads.get();
        if (reads == 0) {
            return 0.0;
        }
        return totalReadTime.get() / (double) reads / 1000.0; // Convert to microseconds
    }

    /**
     * Calculate average write latency in microseconds
     *

  /**
   * Opens a new {@link Stream} for reading text one line at a time from this source. This method
   * returns a new, independent stream each time it is called.
   *
   * <p>The returned stream is lazy and only reads from the source in the terminal operation. If an
   * I/O error occurs while the stream is reading from the source or when the stream is closed, an
   * {@link UncheckedIOException} is thrown.
   *