return standardToArray(array);
      }
    };
  }

  @Override
  @CanIgnoreReturnValue
  public @Nullable B put(Class<? extends @NonNull B> key, @ParametricNullness B value) {
    cast(key, value);
    return super.put(key, value);
  }

  @Override
  public void putAll(Map<? extends Class<? extends @NonNull B>, ? extends B> map) {

   * otherwise create, cache and return" pattern.
   *
   * @since 11.0
   */
  void put(K key, V value);

  /**
   * Copies all of the mappings from the specified map to the cache. 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

    public @Nullable V get(Object key) {
      assertTrue(Thread.holdsLock(mutex));
      return super.get(key);
    }

    @Override
    public @Nullable V put(K key, V value) {
      assertTrue(Thread.holdsLock(mutex));
      return super.put(key, value);
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> map) {
      assertTrue(Thread.holdsLock(mutex));
      super.putAll(map);

   * 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 the specified map is modified while the operation is in progress.
   */
  public void putAll(Map<? extends K, ? extends Long> m) {
    for (Entry<? extends K, ? extends Long> entry : m.entrySet()) {
      put(entry.getKey(), entry.getValue());
    }

    assertThrows(UnsupportedOperationException.class, () -> table.put("foo", 1, 'a'));
    assertSize(0);
  }

  @Override
  public void testPutAllTable() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    Table<String, Integer, Character> other = HashBasedTable.create();
    other.put("foo", 1, 'd');
    other.put("bar", 2, 'e');
    other.put("cat", 2, 'f');

            test.onlyIf((t) -> Util.getBooleanProperty("tests.fips.enabled", false) == false);
            test.setMaxParallelForks(defaultParallel);
        });
        // we put all our distributable files under distributions
        project.getTasks().withType(Jar.class).configureEach(j ->
                j.getDestinationDirectory().set(new File(project.getBuildDir(), "distributions"))
        );
    }

    * Swagger UI.
    * ReDoc.

---

Coming back to the previous code example, **FastAPI** will:

* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.
* Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.
    * If it is not, the client will see a useful, clear error.

# Request Parameters

Here's the reference information for the request parameters.

These are the special functions that you can put in *path operation function* parameters or dependency functions with `Annotated` to get data from the request.

It includes:

* `Query()`
* `Path()`
* `Body()`
* `Cookie()`
* `Header()`
* `Form()`
* `File()`

You can import them all directly from `fastapi`:

```python

        // Prepare test data
        DataStoreParams paramMap = new DataStoreParams();
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("url", "http://example.com/test");
        dataMap.put("title", "Test Document");

        // Execute
        indexUpdateCallback.store(paramMap, dataMap);

        // Verify
        assertEquals(1, indexUpdateCallback.getDocumentSize());

	bucketReplProxiedPutTaggingRequestsFailuresMD = NewCounterMD(bucketReplProxiedPutTaggingRequestsFailures,
		"Number of failures in PUT tagging requests proxied to replication target",
		bucketL, targetArnL)
	bucketReplProxiedPutTaggingRequestsTotalMD = NewCounterMD(bucketReplProxiedPutTaggingRequestsTotal,
		"Number of PUT tagging requests proxied to replication target",
		bucketL, targetArnL)
	bucketReplSentBytesMD = NewCounterMD(bucketReplSentBytes,