# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.

# Rules for building and testing new FIPS snapshots.
# For example:
#
#	make v1.2.3.zip
#	make v1.2.3.test
#
# and then if changes are needed, check them into master
# and run 'make v1.2.3.rm' and repeat.
#
# Note that once published a snapshot zip file should never

        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        InputSource that = (InputSource) o;
        return Objects.equals(modelId, that.modelId)
                && Objects.equals(location, that.location)
                && Objects.equals(inputs, that.inputs);
    }

    @Override
    public int hashCode() {
        return Objects.hash(modelId, location, inputs);
    }

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.jspecify.annotations.Nullable;

/**
 * Thread that finalizes referents. All references should implement {@code
 * com.google.common.base.FinalizableReference}.
 *
 * <p>While this class is public, we consider it to be *internal* and not part of our published API.

	Size      int64
	Objects   uint64
	Versions  uint64 // Versions that are not delete markers.
	ObjSizes  sizeHistogram
	Compacted bool
}

//msgp:tuple dataUsageEntryV6
type dataUsageEntryV6 struct {
	Children dataUsageHashMap
	// These fields do no include any children.
	Size      int64
	Objects   uint64
	Versions  uint64 // Versions that are not delete markers.
	ObjSizes  sizeHistogram
	Compacted bool
}

   * while other events occur sequentially; cancels may occur concurrently with other events. For
   * example, thread A may be executing [responseBodyStart] while thread B executes [canceled].
   * Implementations must support such concurrent calls.
   *
   * Note that cancellation is best-effort and that a call may proceed normally after it has been

      return IntMath.sqrt((int) x, mode);
    }
    /*
     * Let k be the true value of floor(sqrt(x)), so that
     *
     *            k * k <= x          <  (k + 1) * (k + 1)
     * (double) (k * k) <= (double) x <= (double) ((k + 1) * (k + 1))
     *          since casting to double is nondecreasing.
     *          Note that the right-hand inequality is no longer strict.
     * Math.sqrt(k * k) <= Math.sqrt(x) <= Math.sqrt((k + 1) * (k + 1))

                return o instanceof DefaultDependencyResolverRequest that
                        && verbose == that.verbose
                        && requestType == that.requestType
                        && Objects.equals(project, that.project)
                        && Objects.equals(rootArtifact, that.rootArtifact)
                        && Objects.equals(root, that.root)

		// in the beginning of erasure set healing
		if err := bgSeq.healBucket(objAPI, bucket, true); err != nil {
			// Set this such that when we return this function
			// we let the caller retry this disk again for the
			// buckets that failed healing.
			retErr = err
			healingLogIf(ctx, err)
			continue
		}

		var (
			vc   *versioning.Versioning
			lc   *lifecycle.Lifecycle

 * limitations under the License.
 */

package com.google.common.testing;

import com.google.common.annotations.GwtCompatible;
import org.jspecify.annotations.NullMarked;

/**
 * An object that can perform a {@link #tearDown} operation.
 *
 * @author Kevin Bourrillion
 * @since 10.0
 */
@GwtCompatible
@NullMarked
public interface TearDown {
  /**

 */
package org.codelibs.core.collection;

import java.util.Iterator;
import java.util.NoSuchElementException;

import org.codelibs.core.exception.ClUnsupportedOperationException;

/**
 * An {@link Iterator} that returns a single value.
 *
 * @author koichik
 * @param <E> the element type
 */
public class SingleValueIterator<E> implements Iterator<E> {

    /** The only value returned by the iterator. */