HashMultiset<E> multiset = HashMultiset.create();
    multiset.add(freshElement);
    return multiset;
  }

  @Generates
  static <E> LinkedHashMultiset<E> generateLinkedHashMultiset(@Nullable E freshElement) {
    LinkedHashMultiset<E> multiset = LinkedHashMultiset.create();
    multiset.add(freshElement);
    return multiset;
  }

  @Generates

 Notice that before Maven 3.1.0, with logger created by Maven, some code used to pass logger from class to class because it could not create a new logger:

  const TF_Output* const body_inputs;
  TF_Output* const body_outputs;

  // Unique null-terminated name for this while loop. This is used as a prefix
  // for created operations.
  const char* name;
} TF_WhileParams;

// Creates a TF_WhileParams for creating a while loop in `g`. `inputs` are
// outputs that already exist in `g` used as initial values for the loop
// variables.
//

 * explanation.
 *
 * @param <K> the most general key type this builder will be able to create caches for. This is
 *     normally {@code Object} unless it is constrained by using a method like {@link
 *     #removalListener}. Cache keys may not be null.
 * @param <V> the most general value type this builder will be able to create caches for. This is
 *     normally {@code Object} unless it is constrained by using a method like {@link

    this.delegate = new ArrayDeque<>(maxSize);
    this.maxSize = maxSize;
  }

  /**
   * Creates and returns a new evicting queue that will hold up to {@code maxSize} elements.
   *
   * <p>When {@code maxSize} is zero, elements will be evicted immediately after being added to the
   * queue.
   */
  public static <E> EvictingQueue<E> create(int maxSize) {
    return new EvictingQueue<>(maxSize);
  }

  /**

        return ConcurrentHashMultiset.create();
      }
    },
    BOXED_ATOMIC_REPLACE() {
      @Override
      Multiset<Integer> get() {
        return OldConcurrentHashMultiset.create();
      }
    },
    SYNCHRONIZED_MULTISET() {
      @Override
      Multiset<Integer> get() {
        return Synchronized.multiset(HashMultiset.<Integer>create(), null);
      }
    },
    ;

  // TODO(lowasser): implement removeEldestEntry so this can be used as a drop-in replacement

  /** Creates an empty {@code CompactLinkedHashMap} instance. */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactLinkedHashMap<K, V> create() {
    return new CompactLinkedHashMap<>();
  }

  /**
   * Creates a {@code CompactLinkedHashMap} instance, with a high enough "initial capacity" that it

    /**
     * Retrieves the specified class using the context class loader and creates and initializes a new instance of the class using its default constructor.
     *
     * @param <T>
     *            The type of the instance to be created
     * @param className
     *            The class name. Must not be {@literal null} or empty.
     * @return A new object created by invoking the default constructor
     * @throws ClassNotFoundRuntimeException

    private byte[] stats;

    NbtAddress[] addressArray;

    /* It is a little awkward but prudent to pass the quering address
     * so that it may be included in the list of results. IOW we do
     * not want to create a new NbtAddress object for this particular
     * address from which the query is constructed, we want to populate
     * the data of the existing address that should be one of several
     * returned by the node status.
     */

</div>

Il est également inclus lorsque vous installez les extras `all` avec :

<div class="termy">

```console
$ pip install "fastapi[all]"
---> 100%
```

</div>

### Créer l'objet `Settings` { #create-the-settings-object }

Importez `BaseSettings` depuis Pydantic et créez une sous-classe, comme pour un modèle Pydantic.