*   private static final FinalizableReferenceQueue frq = new FinalizableReferenceQueue();
 *   // You might also share this between several objects.
 *
 *   private static final Set<Reference<?>> references = Sets.newConcurrentHashSet();
 *   // This ensures that the FinalizablePhantomReference itself is not garbage-collected.
 *
 *   private final ServerSocket serverSocket;
 *
 *   private MyServer(...) {
 *     ...

   * only when the resulting list may need further modification, or may contain {@code null}. The
   * input is not modified. The returned list is serializable and has random access.
   *
   * <p>Unlike {@link Sets#newTreeSet(Iterable)}, this method does not discard elements that are
   * duplicates according to the comparator. The sort performed is <i>stable</i>, meaning that such

new({{.Element}}), y: new({{.Element}}).One(), z: new({{.Element}}), } } // SetGenerator sets p to the canonical generator and returns p. func (p *{{.P}}Point) SetGenerator() *{{.P}}Point { p.x.SetBytes({{.Gx}}) p.y.SetBytes({{.Gy}}) p.z.One() return p } // Set sets p = q and returns p. func (p *{{.P}}Point) Set(q *{{.P}}Point) *{{.P}}Point { p.x.Set(q.x) p.y.Set(q.y) p.z.Set(q.z) return p } // SetBytes sets p to the compressed, uncompressed, or infinity value encoded in // b, as specified in SEC...

  private void processAllMustSucceedDoneFuture(
      int index, ListenableFuture<? extends InputT> future) {
    try {
      if (future.isCancelled()) {
        // Clear futures prior to cancelling children. This sets our own state but lets
        // the input futures keep running, as some of them may be used elsewhere.
        futures = null;
        cancel(false);
      } else {
        collectValueFromNonCancelledFuture(index, future);

      apply {
        this.message = message
      }

    open fun handshake(handshake: Handshake?) =
      apply {
        this.handshake = handshake
      }

    /**
     * Sets the header named [name] to [value]. If this request already has any headers
     * with that name, they are all replaced.
     */
    open fun header(
      name: String,
      value: String,
    ) = apply {

    return copyToList(asList(elements));
  }

  // Clone of Sets.newLinkedHashSet
  public static <E extends @Nullable Object> Set<E> copyToSet(Iterable<? extends E> elements) {
    Set<E> set = new LinkedHashSet<>();
    addAll(set, elements);
    return set;
  }

  public static <E extends @Nullable Object> Set<E> copyToSet(E[] elements) {
    return copyToSet(asList(elements));
  }

	if objInfo.ModTime.IsZero() || objInfo.ModTime.Equal(time.Unix(0, 0)) {
		return false
	}

	// Headers to be set of object content is not going to be written to the client.
	writeHeaders := func() {
		// set common headers
		setCommonHeaders(w)

		// set object-related metadata headers
		w.Header().Set(xhttp.LastModified, objInfo.ModTime.UTC().Format(http.TimeFormat))

		if objInfo.ETag != "" {

definition of an interface's type set as follows:
</p>

<ul>
	<li>The type set of the empty interface is the set of all non-interface types.
	</li>

	<li>The type set of a non-empty interface is the intersection of the type sets
		of its interface elements.
	</li>

	<li>The type set of a method specification is the set of all non-interface types

        }

        if (!process.isEmpty()) {
            if (!restrictions.isEmpty()) {
                throw new InvalidVersionSpecificationException(
                        "Only fully-qualified sets allowed in multiple set scenario: " + spec);
            } else {
                version = new DefaultArtifactVersion(process);
                restrictions.add(Restriction.EVERYTHING);
            }
        }

			if debugNoExit {
				logger.Info("Not waiting for quorum since we are debugging.. possible cause unhealthy sets")
				logger.Info(result.String())
				break
			}
			d := time.Duration(r.Float64() * float64(time.Second))
			logger.Info("Waiting for quorum READ healthcheck to succeed retrying in %s.. possible cause unhealthy sets", d)
			logger.Info(result.String())
			time.Sleep(d)