// order, and type) the op declaration.  For example, the "Concat" op
// has registration:
//   REGISTER_OP("Concat")
//       .Input("concat_dim: int32")
//       .Input("values: N * T")
//       .Output("output: T")
//       .Attr("N: int >= 2")
//       .Attr("T: type");
// that defines two inputs, "concat_dim" and "values" (in that order).

 * before they are indexed. Ingesters can be used to modify document content,
 * extract additional metadata, or perform other transformations during the
 * indexing process.
 *
 * Ingesters are processed in priority order, with lower numbers having higher priority.
 */
public abstract class Ingester {

    /** Priority of this ingester (lower numbers = higher priority) */
    protected int priority = 99;

    /**

        // without declaring an explicit or implicit dependency. This can lead to incorrect results being produced, depending on what order the tasks are executed.
        tasks.named("publishGradleDistributionPublicationToRemoteRepository") {
            dependsOn("signLocalPublication")
        }
        tasks.named("publishLocalPublicationToLocalRepository") {

        with(standardError) {
            files.forEach {
                assertContains("API changes in file '${it.name}' should be in alphabetical order (by type and member), yet these changes were not:\n")
            }
            changes?.forEach { assertContains(it.toString()) }
            assertContains(cleanupHint)
        }
    }

    private

    ByteBuffer scratch = scratch();
    scratch.putChar(c);
    return update(scratch, Chars.BYTES);
  }

  private ByteBuffer scratch() {
    if (scratch == null) {
      scratch = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
    }
    return scratch;
  }

     *
     * @return the severity level of this problem, never {@code null}
     */
    @Nonnull
    Severity getSeverity();

    /**
     * The different severity levels for a problem, in decreasing order.
     *
     * @since 4.0.0
     */
    @Experimental
    enum Severity {
        FATAL, //
        ERROR, //
        WARNING //
    }

import java.util.Optional;
import java.util.function.UnaryOperator;

import org.apache.maven.api.cli.mvn.MavenOptions;
import org.apache.maven.cling.invoker.LayeredOptions;

/**
 * Options that are "layered" by precedence order.
 *
 * @param <O> the specific type of Maven Options that are layered
 */
public class LayeredMavenOptions<O extends MavenOptions> extends LayeredOptions<O> implements MavenOptions {

  }

  @Generates
  <T> com.google.common.base.Optional<T> generateGoogleOptional(T value) {
    return com.google.common.base.Optional.of(value);
  }

  @Generates
  Joiner generateJoiner() {
    return Joiner.on(generateString());
  }

  @Generates
  Splitter generateSplitter() {
    return Splitter.on(generateString());
  }

  @Generates
  <T> Equivalence<T> generateEquivalence() {

<a href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
{% endfor -%}

### Gold and Silver Sponsors { #gold-and-silver-sponsors }

{% for sponsor in sponsors.gold -%}
<a href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
{% endfor -%}
{%- for sponsor in sponsors.silver -%}

Quand vous déclarez une valeur par défaut pour des paramètres qui ne sont pas des paramètres de chemin (pour l'instant, nous n'avons vu que les paramètres de requête), alors ils ne sont pas requis.

Si vous ne voulez pas leur donner de valeur spécifique mais simplement les rendre optionnels, définissez la valeur par défaut à `None`.

Mais si vous voulez rendre un paramètre de requête obligatoire, vous pouvez simplement ne déclarer aucune valeur par défaut :