* @return true if registration exists
     */
    public boolean hasRegistration(String registrationId) {
        return registrations.containsKey(registrationId);
    }

    /**
     * Simulate sending a witness notification
     *
     * @param eventType the event type
     * @param resourceName the resource name
     */
    public void sendNotification(WitnessEventType eventType, String resourceName) {

3. If the daemon is not able to run the request, for example it is already running a request or is shutting down, it rejects the request. The client starts again.
4. The daemon runs the request, sending back data such as logging output or tooling API events and intermediate models while doing so.

And then you also read how to handle [CORS with the `CORSMiddleware`](../tutorial/cors.md){.internal-link target=_blank}.

In this section we'll see how to use other middlewares.

## Adding ASGI middlewares { #adding-asgi-middlewares }

As **FastAPI** is based on Starlette and implements the <abbr title="Asynchronous Server Gateway Interface">ASGI</abbr> specification, you can use any ASGI middleware.

        return facadeSelectList(createCB(cbLambda));
    }

    public PagingResultBean<WebAuthentication> selectPage(CBCall<WebAuthenticationCB> cbLambda) {
        // #pending same?
        return (PagingResultBean<WebAuthentication>) facadeSelectList(createCB(cbLambda));
    }

    public void selectCursor(CBCall<WebAuthenticationCB> cbLambda, EntityRowHandler<WebAuthentication> entityLambda) {

     * block is automatically generated from the ntstatus package.
     */

    /** The operation completed successfully */
    int NT_STATUS_SUCCESS = 0x00000000;
    /** The request is pending */
    int NT_STATUS_PENDING = 0x00000103;
    /** A notify change request is being completed and information is being returned */
    int NT_STATUS_NOTIFY_ENUM_DIR = 0x0000010C;

 * into itself leading to a stack overflow.
 *
 * A side effect of using @Typed is that it translates to explicit bindings in the container.
 * So instead of binding the component under a 'wildcard' key it is now bound with an explicit
 * key. Since this is a default component, this will be a plain binding of ModelProcessor to
 * this implementation type; that is no hint/name.
 *

    return longBitsToDouble(significand | ONE_BITS);
  }

  static double bigToDouble(BigInteger x) {
    // This is an extremely fast implementation of BigInteger.doubleValue(). JDK patch pending.
    BigInteger absX = x.abs();
    int exponent = absX.bitLength() - 1;
    // exponent == floor(log2(abs(x)))
    if (exponent < Long.SIZE - 1) {
      return x.longValue();
    } else if (exponent > MAX_EXPONENT) {

containers provide isolated application execution environment, orchestration platforms allow seamless scaling by helping replicate and manage containers. MinIO extends this by adding isolated storage environment for each tenant.

MinIO is built ground up on the cloud-native premise. With features like erasure-coding, distributed and shared setup, it focuses only on storage and does it very well. While, it can be scaled by just replicating MinIO instances per tenant via an orchestration platform....

- Language items are cached for 1 hour by `SystemHelper`
- Restart the application after adding new languages

### Auto-Generated Files

Never edit these files manually (marked with `@author FreeGen`):
- `FessLabels.java`
- `FessMessages.java`

Always regenerate them using `mvn dbflute:freegen`

## Complete Example: Adding Swedish (sv)

```bash
# 1. Navigate to resources directory
cd src/main/resources

    @Override public Response intercept(Chain chain) throws IOException {
      long t1 = System.nanoTime();
      Request request = chain.request();
      logger.info(String.format("Sending request %s on %s%n%s",
          request.url(), chain.connection(), request.headers()));
      Response response = chain.proceed(request);

      long t2 = System.nanoTime();