* limitations under the License.
 */

package org.gradle.internal.snapshot.impl;

import com.google.common.collect.ImmutableSet;
import org.gradle.internal.hash.Hashable;
import org.gradle.internal.hash.Hasher;

class AbstractSetSnapshot<T extends Hashable> implements Hashable {
    protected final ImmutableSet<T> elements;

    public AbstractSetSnapshot(ImmutableSet<T> elements) {
        this.elements = elements;
    }

            }});
        }
    }

    private String getViolations(GroovyObjectSupport antBuilder) {
        Object project = antBuilder.getProperty("project");
        Hashtable<?, ?> properties = JavaMethod.of(project, Hashtable.class, "getProperties").invoke(project, new Object[0]);
        return (String) properties.get(VIOLATIONS_ANT_PROPERTY);
    }

     */
    void putString(CharSequence value);

    /**
     * Feed a hash code into the hasher.
     */
    void putHash(HashCode hashCode);

    /**
     * Puts a hashable value into the hasher.
     */
    void put(Hashable hashable);

    /**
     * Feed a {@code null} value into the hasher.
     */
    void putNull();

    /**
     * Returns the combined hash.
     *

        return DEFAULT.hashFile(file);
    }

    /**
     * Hash the given {@code hashable} instance with the default hash function.
     */
    public static HashCode hashHashable(Hashable hashable) {
        Hasher hasher = newHasher();
        hasher.put(hashable);
        return hasher.hash();
    }

    /**
     * The default hashing function.
     */

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

package org.gradle.internal.snapshot;

import org.gradle.internal.hash.Hashable;

import javax.annotation.Nullable;

/**
 * An immutable snapshot of the state of some Java object or object graph.
 *

 * limitations under the License.
 */

package org.gradle.internal.fingerprint;

import org.gradle.internal.file.FileType;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hashable;
import org.gradle.internal.hash.Hashing;

/**
 * An immutable fingerprint of some aspects of a file's metadata and content.
 *

   * part of the smeared hash of the element not covered by the hashtable mask, whereas the low bits
   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb

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

package org.gradle.internal.isolation;

import org.gradle.internal.hash.Hashable;
import org.gradle.internal.snapshot.ValueSnapshot;

import javax.annotation.Nullable;

/**
 * Isolatable objects can return an isolated instance of the given type T from which this object was created.

import com.google.common.collect.testing.Helpers;
import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.collect.testing.features.MapFeature;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.Map;
import junit.framework.AssertionFailedError;
import org.junit.Ignore;

/**
 * A generic JUnit test which tests {@link Map#merge}. Can't be invoked directly; please see {@link

           device == rhs.device && op == rhs.op;
  }

  // Make ResourceHandle hashable.
  friend ::llvm::hash_code hash_value(const ResourceHandle& resource_handle);

  StringRef container;
  StringRef name;
  StringRef device;
  Operation* op = nullptr;
};

// Make ResourceHandle hashable.
inline ::llvm::hash_code hash_value(const ResourceHandle& resource_handle) {