* elements, including {@code null}, are permitted.
 *
 * <p>{@code contains(x)}, {@code add(x)} and {@code remove(x)}, are all (expected and amortized)
 * constant time operations. Expected in the hashtable sense (depends on the hash function doing a
 * good job of distributing the elements to the buckets to a distribution not far from uniform), and
 * amortized since some operations can trigger a hash table resize.
 *

 * limitations under the License.
 */

package org.gradle.internal.hash;

/**
 * A snapshot of the state of some thing.
 */
public interface Hashable {
    /**
     * Appends the snapshot to the given hasher.
     */
    void appendToHasher(Hasher hasher);

 */

package org.gradle.internal.snapshot.impl;

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

class AbstractMapSnapshot<T extends Hashable> implements Hashable {
    protected final ImmutableList<MapEntrySnapshot<T>> entries;

    public AbstractMapSnapshot(ImmutableList<MapEntrySnapshot<T>> entries) {

 * limitations under the License.
 */

package org.gradle.internal.snapshot.impl;

import org.gradle.internal.hash.Hashable;
import org.gradle.internal.hash.Hasher;

class AbstractManagedValueSnapshot<T extends Hashable> implements Hashable {
    protected final T state;

    public AbstractManagedValueSnapshot(T state) {
        this.state = state;
    }

    public T getState() {

        expect:
        actionLambdaSnapshot != consumerLambdaSnapshot
        hash(actionLambdaSnapshot) != hash(consumerLambdaSnapshot)
    }

    private HashCode hash(Hashable hashable) {
        def hasher = Hashing.newHasher()
        hasher.put(hashable)
        return hasher.hash()
    }

    private ImplementationSnapshot createLambdaSnapshot(lambda) {

 */

package org.gradle.internal.snapshot.impl;

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

import java.util.List;

class AbstractArraySnapshot<T extends Hashable> implements Hashable {
    protected final ImmutableList<T> elements;

    public AbstractArraySnapshot(ImmutableList<T> elements) {
        this.elements = elements;

 */

package org.gradle.internal.snapshot.impl;

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

import java.util.List;

class AbstractListSnapshot<T extends Hashable> implements Hashable {
    protected final ImmutableList<T> elements;

    public AbstractListSnapshot(ImmutableList<T> elements) {
        this.elements = elements;

 * 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;
    }

     */
    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.
     *

 * 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.
 *