@CanIgnoreReturnValue
  MapMaker setValueStrength(Strength strength) {
    checkState(valueStrength == null, "Value strength was already set to %s", valueStrength);
    valueStrength = checkNotNull(strength);
    if (strength != Strength.STRONG) {
      // STRONG could be used during deserialization.
      useCustomMap = true;
    }
    return this;
  }

  Strength getValueStrength() {

        }
      };

  private CacheBuilderFactory factoryWithAllKeyStrengths() {
    return new CacheBuilderFactory()
        .withKeyStrengths(ImmutableSet.of(STRONG, Strength.WEAK))
        .withValueStrengths(ImmutableSet.of(STRONG, Strength.WEAK, Strength.SOFT));
  }

  private Iterable<LoadingCache<Key, String>> caches() {
    CacheBuilderFactory factory = factoryWithAllKeyStrengths();
    return Iterables.transform(

   * @throws IllegalStateException if the key strength was already set
   */
  @GwtIncompatible // java.lang.ref.WeakReference
  @CanIgnoreReturnValue
  public CacheBuilder<K, V> weakKeys() {
    return setKeyStrength(Strength.WEAK);
  }

  @CanIgnoreReturnValue
  CacheBuilder<K, V> setKeyStrength(Strength strength) {
    checkState(keyStrength == null, "Key strength was already set to %s", keyStrength);

      MapMaker builder) {
    if (builder.getKeyStrength() == Strength.STRONG
        && builder.getValueStrength() == Strength.STRONG) {
      return new MapMakerInternalMap<>(builder, StrongKeyStrongValueEntry.Helper.<K, V>instance());
    }
    if (builder.getKeyStrength() == Strength.STRONG
        && builder.getValueStrength() == Strength.WEAK) {

    checkStrength(map, Strength.WEAK, Strength.STRONG);
    assertSame(EntryFactory.WEAK, map.entryFactory);
  }

  public void testSetWeakValues() {
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().weakValues());
    checkStrength(map, Strength.STRONG, Strength.WEAK);
    assertSame(EntryFactory.STRONG, map.entryFactory);
  }

      }
      statsCounter.recordEviction();
      return removal;
    }
  }

  /**
   * Any updates to LocalCache.Strength used in CacheBuilder need to be matched in this class for
   * compilation purposes.
   */
  enum Strength {
    /*
     * TODO(kevinb): If we strongly reference the value and aren't loading, we needn't wrap the
     * value. This could save ~8 bytes per entry.
     */

That's why it makes a lot of sense to use asynchronous ⏸🔀⏯ code for web APIs.

This kind of asynchronicity is what made NodeJS popular (even though NodeJS is not parallel) and that's the strength of Go as a programming language.

And that's the same level of performance you get with **FastAPI**.

        ndrBuffer.advance(10);
        assertEquals(10, ndrBuffer.getLength());

        ndrBuffer.setLength(20);
        assertEquals(20, ndrBuffer.getLength());

        // Test with derived buffer
        NdrBuffer derived = ndrBuffer.derive(0);
        derived.setLength(5);
        assertEquals(5, derived.getLength());

        when(tree.send(any(jcifs.internal.Request.class), any(RequestParam.class))).thenReturn(null);

        raf.setLength(100L);

        verify(tree, times(1)).send(any(Smb2SetInfoRequest.class), eq(RequestParam.NO_RETRY));
    }

    @Test
    @DisplayName("setLength(): NT SMBs capability uses Trans2SetFileInformation")
    void setLength_ntsmbs_usesTrans2() throws Exception {

        int notificationType = buf.dec_ndr_long();
        notification.setNotificationType(WitnessEventType.fromValue(notificationType));

        // Length
        int length = buf.dec_ndr_long();
        notification.setLength(length);

        // Number of messages
        int numberOfMessages = buf.dec_ndr_long();

        // Messages array
        List<WitnessNotificationMessage> messages = new ArrayList<>(numberOfMessages);