return BucketOrder.count(asc);
                }
            }
        }
        return BucketOrder.count(false);
    }

    /**
     * Adds a query facet to the existing query array.
     * If no queries exist, creates a new array with the provided query.
     *
     * @param s the query string to add as a facet
     */

  }

  /**
   * Atomically adds the given value to the element at index {@code i}.
   *
   * @param i the index
   * @param delta the value to add
   * @return the previous value
   */
  @CanIgnoreReturnValue
  public final double getAndAdd(int i, double delta) {
    return getAndAccumulate(i, delta, Double::sum);
  }

  /**
   * Atomically adds the given value to the element at index {@code i}.

  private final Object lock = new Object();

  /** We will keep a private list of all logged records */
  @GuardedBy("lock")
  private final List<LogRecord> list = new ArrayList<>();

  /** Adds the most recently logged record to our list. */
  @Override
  public void publish(@Nullable LogRecord record) {
    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }
    }
  }

     */
    public boolean isValidFileProtocol(final String url) {
        return stream(fileProtocols).get(stream -> stream.anyMatch(s -> url.startsWith(s)));
    }

    /**
     * Adds a new web protocol to the supported protocols list.
     * If the protocol already exists, it will not be added again.
     *
     * @param protocol the protocol name to add (without colon suffix)
     */

        try {
            return ps.executeBatch();
        } catch (final SQLException ex) {
            throw new SQLRuntimeException(ex);
        }
    }

    /**
     * Adds a batch.
     *
     * @param ps
     *            {@link PreparedStatement}. Must not be {@literal null}.
     * @throws SQLRuntimeException
     *             If a {@link SQLException} occurs.
     */

Here's a visual representation of how the **proxy** adds forwarded headers between the client and the **application server**:

```mermaid
sequenceDiagram
    participant Client
    participant Proxy as Proxy/Load Balancer
    participant Server as FastAPI Server

    Client->>Proxy: HTTPS Request<br/>Host: mysuperapp.com<br/>Path: /items

    Note over Proxy: Proxy adds forwarded headers

    @Resource
    protected FavoriteLogBhv favoriteLogBhv;

    /** Configuration settings for the Fess search system. */
    @Resource
    protected FessConfig fessConfig;

    /**
     * Adds a URL to a user's favorite list.
     * This method looks up the user by their code and creates a new favorite log entry
     * using the provided lambda function to populate the favorite log data.
     *

        assertEquals(0x12, buffer[1] & 0xFF);
        // Check that the path is written after the referral level
        // The path should be written starting at index 2
        // writeString adds null terminator
        assertTrue(len > 2, "Length should include path");
        String writtenPath = extractStringFromBuffer(buffer, 2, len - 2);
        assertTrue(writtenPath.contains("abc"), "Path should be written to buffer");

    int numberOfThreads = 64;
    runConcurrentTest(
        numberOfThreads,
        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() throws Exception {
            // adds two nanoseconds to the ticker
            ticker.advance(1L);
            Thread.sleep(10);
            ticker.advance(1L);
            return null;
          }
        });

///

/// note | Starlette Technical Details

**FastAPI**'s `UploadFile` inherits directly from **Starlette**'s `UploadFile`, but adds some necessary parts to make it compatible with **Pydantic** and the other parts of FastAPI.

///

## What is "Form Data" { #what-is-form-data }