chain.doFilter(request, response);
            return;
        }

        final short cpuPercent = ComponentUtil.getSystemHelper().getSearchEngineCpuPercent();

        if (cpuPercent < threshold) {
            chain.doFilter(request, response);
            return;
        }

        if (logger.isInfoEnabled()) {

            Object v = valueRef.get();
            if (v == null) {
              throw new ExecutionException(cause);
            }
            return v;
          }

          @Override
          public @Nullable Object getIfPresent(Object key) {
            return valueRef.get();
          }
        };

    UncheckedExecutionException expected =

    /**
     * Gets the salt value used for preauth integrity.
     *
     * @return the salt
     */
    public byte[] getSalt() {
        return this.salt;
    }

    /**
     * Gets the supported hash algorithms for preauth integrity.
     *
     * @return the hashAlgos
     */
    public int[] getHashAlgos() {
        return this.hashAlgos;
    }

    /**
     * {@inheritDoc}
     *

        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyExecutionListener(this, listener);
    }

    public RepositoryListener chainListener(RepositoryListener listener) {
        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyRepositoryListener(this, listener);
    }

  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  public boolean contains(@Nullable Object target) {
    return element.equals(target);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return singletonIterator(element);
  }

  @Override
  public ImmutableList<E> asList() {
    return ImmutableList.of(element);
  }

  @Override

        delegate = new MetadataStaxReader(contentTransformer::transform);
    }

    /**
     * Returns the state of the "add default entities" flag.
     *
     * @return boolean a field value
     */
    public boolean getAddDefaultEntities() {
        return delegate.getAddDefaultEntities();
    }

    /**
     * Sets the state of the "add default entities" flag.
     *

		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	config, err := globalBucketVersioningSys.Get(bucket)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	configData, err := xml.Marshal(config)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// Write bucket versioning configuration to client

                Integer.parseInt(actualVersion.getMajorVersion())
            );
        }

        return actualVersion;
    }

    private InstallationLocation getJavaInstallation(File javaHome) {
        return getAvailableJavaInstallationLocationSteam().filter(installationLocation -> isSameFile(javaHome, installationLocation))
            .findFirst()

    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue
  static long checkPositive(String role, long x) {
    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue
  static BigInteger checkPositive(String role, BigInteger x) {

 */
public interface RdmaProvider {

    /**
     * Check if RDMA is available on this system
     *
     * @return true if RDMA can be used, false otherwise
     */
    boolean isAvailable();

    /**
     * Get supported RDMA capabilities
     *
     * @return set of capabilities supported by this provider
     */
    Set<RdmaCapability> getSupportedCapabilities();

    /**