* @param <N> Node parameter type
 */
abstract class AbstractBaseGraph<N> implements BaseGraph<N> {

  /**
   * Returns the number of edges in this graph; used to calculate the size of {@link Graph#edges()}.
   * This implementation requires O(|N|) time. Classes extending this one may manually keep track of
   * the number of edges as the graph is updated, and override this method for better performance.
   */
  protected long edgeCount() {

    private int tflags;
    private Referral[] referrals;

    /**
     * Get the number of characters consumed from the path
     *
     * @return the pathConsumed
     */
    public final int getPathConsumed() {
        return this.pathConsumed;
    }

    /**
     * Get the number of referrals in the response
     *
     * @return the numReferrals
     */

     * @throws SmbException if an error occurs checking protocol version
     */
    boolean isSMB2() throws SmbException;

    /**
     * Gets the number of currently pending requests.
     *
     * @return number of inflight requests
     */
    int getInflightRequests();

MinIO server allows to throttle incoming requests:

- limit the number of active requests allowed across the cluster
- limit the wait duration for each request in the queue

These values are enabled using server's configuration or environment variables.

## Examples

     */
    public UserInfoService() {
        // Default constructor
    }

    /**
     * Deletes user information records older than the specified number of days.
     * This method is used for data cleanup and maintenance operations.
     *
     * @param days the number of days to keep user information records
     */
    public void deleteBefore(final int days) {
        userInfoBhv.queryDelete(cb -> {

   *
   * @param q the blocking queue to be drained
   * @param buffer where to add the transferred elements
   * @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up
   * @return the number of elements transferred
   * @throws InterruptedException if interrupted while waiting
   * @since 33.4.0 (but since 28.0 in the JRE flavor)
   */

    }

    /**
     * Gets the major version number of the current Java runtime.
     * For Java 8 and below, returns the minor version (e.g., 8 for Java 1.8).
     * For Java 9 and above, returns the major version (e.g., 11 for Java 11).
     *
     * @return the Java version number, defaults to 8 if version cannot be determined
     */
    public static int getJavaVersion() {

     * @return number of bytes written
     */
    protected abstract int writeBytesWireFormat(byte[] dst, int dstIndex);

    /**
     * Reads the message body from the wire format.
     *
     * @param buffer the buffer to read from
     * @param bufferIndex the starting position in the buffer
     * @return number of bytes read

    }

    /**
     * Sets the minimum number of bytes that must be read for the operation to succeed
     *
     * @param minimumCount
     *            the minimumCount to set
     */
    public void setMinimumCount(final int minimumCount) {
        this.minimumCount = minimumCount;
    }

    /**
     * Sets the number of bytes remaining to be read after this request
     *

- Greater than `REDUCED_REDUNDANCY` parity, if it is set.

Parity blocks can not be higher than data blocks, so `STANDARD` storage class parity can not be higher than N/2. (N being total number of drives)

The default value for the `STANDARD` storage class depends on the number of volumes in the erasure set:

| Erasure Set Size | Default Parity (EC:N) |
|------------------|-----------------------|
| 5 or fewer       |                 EC:2  |