// trying to read the canonical...
        @SuppressWarnings("rawtypes") // using raw types to avoid a bug in our nullness checker :(
        InternalEntry entry = map.getEntry(sample);
        if (entry != null) {
          Object canonical = entry.getKey();
          if (canonical != null) { // only matters if weak/soft keys are used
            // The compiler would know this is safe if not for our use of raw types (see above).

		for _, endpoint := range minioEndpoints {
			if net.ParseIP(endpoint) == nil {
				// Checking if the IP is a DNS entry.
				addrs, err := globalDNSCache.LookupHost(GlobalContext, endpoint)
				if err != nil {
					logger.FatalIf(err, "Unable to initialize MinIO server with [%s] invalid entry found in MINIO_PUBLIC_IPS", endpoint)
				}
				for _, addr := range addrs {
					domainIPs.Add(addr)
				}
			}

# Enables RBE as long as RBE is available for the selected platform.
# The "selected" platform is considered to be
# TFCI_BAZEL_TARGET_SELECTING_CONFIG_PREFIX. "Available" means there is
# an entry in tensorflow/.bazelrc for build:rbe_TFCI_BAZEL_TARGET...
#                                           ^^^^
# This env is only valid when RBE is available on the selected platform, since

Mais vous pouvez retourner une `JSONResponse` directement à partir de vos *opérations de chemin*.

Cela peut être utile, par exemple, pour retourner des en-têtes personnalisés ou des cookies.

## Renvoyer une `Response`

En fait, vous pouvez retourner n'importe quelle `Response` ou n'importe quelle sous-classe de celle-ci.

   * unless the value is {@code null}.
   *
   * <p>Any existing entry spanning either range boundary may be split at the boundary, even if the
   * merge does not affect its value. For example, if {@code rangeMap} had one entry {@code [1, 5]
   * => 3} then {@code rangeMap.merge(Range.closed(0,2), 3, Math::max)} could yield a map with the

  // Returns a map from variable names to their shapes.  Slices of a partitioned
  // tensor are combined into a single entry.
  const TensorSliceReader::VarToShapeMap& GetVariableToShapeMap() const;

  // Returns a map from variable names to their data types.  Slices of a
  // partitioned tensor are combined into a single entry.
  const TensorSliceReader::VarToDataTypeMap& GetVariableToDataTypeMap() const;

import com.google.common.collect.testing.features.MapFeature;
import com.google.common.testing.EqualsTester;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.junit.Ignore;

/**
 * Tester for {@code Multimap.equals}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible

        if (StringUtil.isNotBlank(logFilePath)) {
            final Path logDirPath = Paths.get(logFilePath);
            try (Stream<Path> stream = Files.list(logDirPath)) {
                stream.filter(entry -> isLogFilename(entry.getFileName().toString())).sorted().forEach(filePath -> {
                    final Map<String, Object> map = new HashMap<>();
                    final String name = filePath.getFileName().toString();

    mod.put("foo", 1);
    Entry<String, Integer> fromIterator = unmod.entries().iterator().next();
    assertThrows(UnsupportedOperationException.class, () -> fromIterator.setValue(2));
    Entry<String, Integer> fromToArray = (Entry<String, Integer>) unmod.entries().toArray()[0];
    assertThrows(UnsupportedOperationException.class, () -> fromToArray.setValue(2));

    #    ; map:{code=0; name=False; alias=Unchecked; comment=means no ; sisterCode=false}
    #}
    # example for table classification
    #; MemberStatus = list:{
    #    ; map:{topComment=status of member from entry to withdrawal; codeType=String}
    #    ; map:{
    #        ; table=MEMBER_STATUS
    #        ; code=MEMBER_STATUS_CODE; name=MEMBER_STATUS_NAME
    #        ; comment=DESCRIPTION; orderBy=DISPLAY_ORDER
    #    }