if (existing != null) return existing

    if (computed == null) {
      computed = compute()
    }

    // If we successfully add the computed element, we're done.
    val newTags = tags.plus(type, computed)
    if (compareAndSet(tags, newTags)) return computed

    // We lost the race. Possibly to other code that was putting a *different* key. Try again!
  }

 *
 * As a non-default component this now gets a negative priority relative to other implementations
 * of the same interface. Since we want to allow overriding this doesn't matter in this case.
 * (if it did we could add @Priority of 0 to match the priority given to default components.)
 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@Named("core-default")

				p.errs[i] = io.ErrShortWrite
				p.writers[i] = nil
			}
		} else {
			p.writers[i] = nil
		}
	}

	// If nilCount >= p.writeQuorum, we return nil. This is because HealFile() uses
	// CreateFile with p.writeQuorum=1 to accommodate healing of single disk.
	// i.e if we do no return here in such a case, reduceWriteQuorumErrs() would
	// return a quorum error to HealFile().
	nilCount := countErrs(p.errs, nil)

	} else {
		cr.buffer = cr.buffer[:size]
	}

	// Now, we read the payload.
	_, err = io.ReadFull(cr.reader, cr.buffer)
	if err == io.EOF && size != 0 {
		err = io.ErrUnexpectedEOF
	}
	if err != nil && err != io.EOF {
		cr.err = err
		return n, cr.err
	}

	// If the chunk size is zero we return io.EOF. As specified by AWS,
	// only the last chunk is zero-sized.

   * process in any way, for example being sent over RPC, or saved to disk. For a general-purpose,
   * non-cryptographic hash function that will never change behavior, we suggest {@link
   * #murmur3_128}.
   *
   * <p>Repeated calls to this method on the same loaded {@code Hashing} class, using the same value

	switch ef.Type {
	case BatchJobExpireObject:
		if obj.DeleteMarker {
			return false
		}
	case BatchJobExpireDeleted:
		if !obj.DeleteMarker {
			return false
		}
	default:
		// we should never come here, Validate should have caught this.
		batchLogOnceIf(context.Background(), fmt.Errorf("invalid filter type: %s", ef.Type), ef.Type)
		return false
	}

  implementation(libs.bouncycastle.bctls)
  api(libs.conscrypt.openjdk)
  api(libs.openjsse)

  api(rootProject.libs.junit.jupiter.engine)

  // This runs Corretto on macOS (aarch64) and Linux (x86_64). We don't test Corretto on other
  // operating systems or architectures.
  api(variantOf(libs.amazonCorretto) {
    classifier(
      when {
        OperatingSystem.current().isMacOsX -> "osx-aarch_64"

        if (Objects.equals(key, keys[next])) {
          int oldValue = values[next];

          if (last == UNSET) {
            // we need to update the root link from table[]
            table[tableIndex] = getNext(entries[next]);
          } else {
            // we need to update the link from the chain
            entries[last] = swapNext(entries[last], getNext(entries[next]));
          }

	if !postPolicyForm.Expiration.After(UTCNow()) {
		return fmt.Errorf("Invalid according to Policy: Policy expired")
	}

	// mustFindInPolicy is a map to list all the keys that we must find in the policy as
	// we process it below. At the end of checkPostPolicy function, if any key is left in
	// this map, that's an error.
	mustFindInPolicy := make(map[string][]string, len(formValues))
	for key, values := range formValues {

 * @author Louis Wasserman
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
@SuppressWarnings({
  // @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
  "JUnit4ClassUsedInJUnit3",
  // We use ::iterator so that we test passing a plain Iterable, not a Collection.
  "UnnecessaryMethodReference",
})