// WidthCap returns the cap width of the byte arrays in this pool.
func (bp *BytePoolCap) WidthCap() (n int) {
	if bp == nil {
		return 0
	}
	return bp.wcap
}

// CurrentSize returns current size of buffer pool
func (bp *BytePoolCap) CurrentSize() int {
	if bp == nil {
		return 0
	}
	return len(bp.c) * bp.w

				return
			}
		case "ts":
			z.TotalSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "TotalSize")
				return
			}
		case "cs":
			z.CurrentSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "CurrentSize")
				return
			}
		case "cmp":
			z.Complete, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Complete")
				return
			}
		case "fl":

type PoolDecommissionInfo struct {
	StartTime   time.Time `json:"startTime" msg:"st"`
	StartSize   int64     `json:"startSize" msg:"ss"`
	TotalSize   int64     `json:"totalSize" msg:"ts"`
	CurrentSize int64     `json:"currentSize" msg:"cs"`

	Complete bool `json:"complete" msg:"cmp"`
	Failed   bool `json:"failed" msg:"fl"`
	Canceled bool `json:"canceled" msg:"cnl"`

	// Internal information.

                return existing;
            }
        }

        // Check pool size limits using atomic operation
        if (!nonPooled) {
            int currentSize = this.connections.size();
            if (currentSize >= maxPoolSize) {
                // Try to remove idle connections
                removeIdleConnections();

                // If still at limit, throw exception

    this.entries[entryIndex] = ((long) hash << 32) | (NEXT_MASK & UNSET);
    this.keys[entryIndex] = key;
    this.values[entryIndex] = value;
  }

  /** Returns currentSize + 1, after resizing the entries storage if necessary. */
  private void resizeMeMaybe(int newSize) {
    int entriesSize = entries.length;
    if (newSize > entriesSize) {

    assertBytes(0x40, 3, 'f'.code, 'a'.code, 'r'.code, 3, 'b'.code, 'o'.code, 'o'.code)
  }

  @Test
  fun noDynamicTableSizeUpdateWhenSizeIsEqual() {
    val currentSize = hpackWriter!!.headerTableSizeSetting
    hpackWriter!!.resizeHeaderTable(currentSize)
    hpackWriter!!.writeHeaders(listOf(Header("foo", "bar")))
    assertBytes(0x40, 3, 'f'.code, 'o'.code, 'o'.code, 3, 'b'.code, 'a'.code, 'r'.code)
  }

  @Test

import java.io.File


internal
sealed class ApiSourceFile {

    internal
    abstract val currentFile: File

    internal
    abstract val currentSourceRoot: File

    @ConsistentCopyVisibility
    data class Java internal constructor(

        override val currentFile: File,

        override val currentSourceRoot: File

    ) : ApiSourceFile()

    @ConsistentCopyVisibility

        final String username = systemHelper.getUsername();
        final long currentTime = systemHelper.getCurrentTimeAsLong();
        return getEntity(form, username, currentTime).map(entity -> {
            entity.setUpdatedBy(username);
            entity.setUpdatedTime(currentTime);
            copyBeanToBean(form, entity,

        final String username = systemHelper.getUsername();
        final long currentTime = systemHelper.getCurrentTimeAsLong();
        return getEntity(form, username, currentTime).map(entity -> {
            entity.setUpdatedBy(username);
            entity.setUpdatedTime(currentTime);
            BeanUtil.copyBeanToBean(form, entity,
                    op -> op.exclude(Constants.COMMON_CONVERSION_RULE)

                    return;
                }

                long currentTime = SystemUtil.currentTimeMillis();
                long delayTime = lastValue + delayMillisBeforeProcessing - currentTime;
                while (delayTime > 0) {
                    lastTime.wait(delayTime);
                    currentTime = SystemUtil.currentTimeMillis();