func (t *Mask) SetIf(b bool, other Mask) {
	if b {
		*t |= other
	}
}

// Mask returns the mask as a uint64.
func (t Mask) Mask() uint64 {
	return uint64(t)
}

// Maskable implementations must return their mask as a 64 bit uint.
type Maskable interface {
	Mask() uint64

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import com.google.common.math.IntMath;
import java.math.RoundingMode;

/** Benchmark of implementations of {@link ImmutableSet#hashFloodingDetected(Object[])}. */
public class ImmutableSetHashFloodingDetectionBenchmark {
  private static final int TEST_CASES = 0x100;

  @Param({"10", "100", "1000", "10000"})
  int size;

 * under the License.
 */
package org.apache.maven.repository.metadata;

import org.apache.maven.artifact.ArtifactScopeEnum;

/**
 * Resolves conflicts in the supplied dependency graph.
 * Different implementations will implement different conflict resolution policies.
 *
 */
@Deprecated
public interface GraphConflictResolver {
    String ROLE = GraphConflictResolver.class.getName();

    /**

        // We need to set the file here or the resolver will fail with an NPE, not fully equipped to deal
        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        return artifact;
    }

    @Override
    public String getId() {
        return localRepository.getId();
    }

    @Override

)

// format.json currently has the format:
// {
//   "version": "1",
//   "format": "XXXXX",
//   "XXXXX": {
//
//   }
// }
// Here "XXXXX" depends on the backend, currently we have "fs" and "xl" implementations.
// formatMetaV1 should be inherited by backend format structs. Please look at format-fs.go
// and format-xl.go for details.

// Ideally we will never have a situation where we will have to change the

  E next();

  /**
   * {@inheritDoc}
   *
   * <p>Implementations may or may not support removal when a call to {@link #peek()} has occurred
   * since the most recent call to {@link #next()}.
   *
   * @throws IllegalStateException if there has been a call to {@link #peek()} since the most recent
   *     call to {@link #next()} and this implementation does not support this sequence of calls
   *     (optional)
   */

   */
  boolean apply(@ParametricNullness T input);

  /**
   * Indicates whether another object is equal to this predicate.
   *
   * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.
   * However, an implementation may also choose to return {@code true} whenever {@code object} is a
   * {@link Predicate} that it considers <i>interchangeable</i> with this one. "Interchangeable"

import com.google.errorprone.annotations.concurrent.GuardedBy;
import java.util.concurrent.Executor;
import java.util.logging.Level;
import javax.annotation.CheckForNull;

/**
 * A support class for {@code ListenableFuture} implementations to manage their listeners. An
 * instance contains a list of listeners, each with an associated {@code Executor}, and guarantees
 * that every {@code Runnable} that is {@linkplain #add added} will be executed after {@link

/**
 * This class provides a skeletal implementation of the {@link Multiset} interface. A new multiset
 * implementation can be created easily by extending this class and implementing the {@link
 * Multiset#entrySet()} method, plus optionally overriding {@link #add(Object, int)} and {@link
 * #remove(Object, int)} to enable modifications to the multiset.
 *
 * <p>The {@link #count} and {@link #size} implementations all iterate across the set returned by

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.cache;

/**
 * Utility {@link Weigher} implementations intended for use in testing.
 *
 * @author Charles Fry
 */
public class TestingWeighers {

  /** Returns a {@link Weigher} that returns the given {@code constant} for every request. */