public long put(K key, long newValue) {
    return getAndUpdate(key, x -> newValue);
  }

  /**
   * Copies all of the mappings from the specified map to this map. The effect of this call is
   * equivalent to that of calling {@code put(k, v)} on this map once for each mapping from key
   * {@code k} to value {@code v} in the specified map. The behavior of this operation is undefined

//
// If operating in binary mode, this assumes strict GNU binary mode; which means
// that the first byte can only be either 0x80 or 0xff. Thus, the first byte is
// equivalent to the sign bit in two's complement form.
func fitsInBase256(n int, x int64) bool {
	binBits := uint(n-1) * 8
	return n >= 9 || (x >= -1<<binBits && x < 1<<binBits)
}

- **Crawler > File**: Check file crawling configurations (SMB, FTP)
- **System > General**: Verify URL patterns and filters

**GSA Configuration Mapping**

| GSA Setting | Fess Equivalent |
|-------------|----------------|
| Collection | WebConfig or FileConfig |
| Start URLs | URLs field in crawl config |
| Good URL Pattern | Included URLs (regex) |
| Bad URL Pattern | Excluded URLs (regex) |

     * found, the existing values are replaced.
     */
    operator fun set(
      name: String,
      value: String,
    ) = commonSet(name, value)

    /** Equivalent to `build().get(name)`, but potentially faster. */
    operator fun get(name: String): String? = commonGet(name)

    fun build(): Headers = commonBuild()
  }

  companion object {
    /** Empty headers. */

   * For example, a lexicographical natural ordering over integers considers {@code [] < [1] < [1,
   * 1] < [1, 2] < [2]}.
   *
   * <p>Note that {@code Collections.reverseOrder(lexicographical(comparator))} is not equivalent to
   * {@code lexicographical(Collections.reverseOrder(comparator))} (consider how each would order
   * {@code [1]} and {@code [1, 1]}).
   */

#### About `**user_dict` { #about-user-dict }

`UserInDB(**user_dict)` means:

*Pass the keys and values of the `user_dict` directly as key-value arguments, equivalent to:*

```Python
UserInDB(
    username = user_dict["username"],
    email = user_dict["email"],
    full_name = user_dict["full_name"],
    disabled = user_dict["disabled"],

Donc :

```Python
q: Union[str, None] = Query(default=None)
```

... rend le paramètre optionnel, et est donc équivalent à :

```Python
q: Union[str, None] = None
```

Mais déclare explicitement `q` comme étant un paramètre de requête.

/// info

  }

  /**
   * Waits until the given weak reference is cleared, invoking the garbage collector as necessary to
   * try to ensure that this will happen.
   *
   * <p>This is a convenience method, equivalent to:
   *
   * {@snippet :
   * awaitDone(new FinalizationPredicate() {
   *   public boolean isDone() {
   *     return ref.get() == null;
   *   }
   * });
   * }
   *

     *
     * Expected outputs are generated by the code itself, but they've been
     * checked against the inputs under Bash in order to confirm that the two
     * forms are equivalent (though not necessarily minimal, though we hope this
     * to be the case). Thus, this test is more of a regression test.
     *
     * Rough instructions to regenerate the test outputs and verify correctness:

}

my_second_user: User = User(**second_user_data)
```

/// info

`**second_user_data` means:

Pass the keys and values of the `second_user_data` dict directly as key-value arguments, equivalent to: `User(id=4, name="Mary", joined="2018-11-30")`

///

### Editor support { #editor-support }