}

  @Override
  public HashCode hashInt(int input) {
    return hashBytes(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(input).array());
  }

  @Override
  public HashCode hashLong(long input) {
    return hashBytes(ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).putLong(input).array());
  }

  @Override
  public HashCode hashUnencodedChars(CharSequence input) {

        int hash = safeHash(version);
        hash = 31 * hash + name.hashCode();
        hash = 31 * hash + group.hashCode();
        return  hash;
    }

    private static int safeHash(@Nullable String o) {
        return o == null ? 0 : o.hashCode();
    }

    @Override
    public String getGroup() {
        return group;
    }

    @Override

    @Override
    public void store(final ArtifactAtRepositoryKey key, final File artifactFile, HashCode moduleDescriptorHash) {
        assertArtifactFileNotNull(artifactFile);
        assertKeyNotNull(key);
        storeInternal(key, createEntry(artifactFile, moduleDescriptorHash));
    }

    private DefaultCachedArtifact createEntry(File artifactFile, HashCode moduleDescriptorHash) {

 * limitations under the License.
 */

package org.gradle.internal.classloader;

import com.google.common.base.Charsets;
import org.gradle.internal.hash.ClassLoaderHierarchyHasher;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hasher;
import org.gradle.internal.hash.Hashing;

import javax.annotation.Nullable;
import java.util.Map;
import java.util.WeakHashMap;

        protected final Set<ComponentArtifactMetadata> artifacts;
        protected final HashCode moduleDescriptorHash;
        protected final long createTimestamp;

        ModuleArtifactsCacheEntry(Set<? extends ComponentArtifactMetadata> artifacts, long createTimestamp, HashCode moduleDescriptorHash) {
            this.artifacts = new LinkedHashSet<>(artifacts);
            this.createTimestamp = createTimestamp;

    public interface AbsentValueProvider<T> {

        T provide();
    }

    public static class WeakKey<T> extends WeakReference<T> {
        private final int hashCode;

        public WeakKey(T referent) {
            super(referent);
            hashCode = System.identityHashCode(referent);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) {

    interface ArchivedFileCollectionFingerprintFactory {
        FileCollectionFingerprint createArchivedFileCollectionFingerprint(Map<String, FileSystemLocationFingerprint> fingerprints, ImmutableMultimap<String, HashCode> rootHashes, HashCode strategyConfigurationHash);
    }

            && dslId.equals(key.dslId);
    }

    @Override
    public int hashCode() {
        ClassLoader loader = this.classLoader.get();
        int result = className.hashCode();
        result = 31 * result + (loader != null ? loader.hashCode() : 1);
        result = 31 * result + dslId.hashCode();
        return result;
    }

        ModuleAtRepositoryKey other = (ModuleAtRepositoryKey) o;
        return repositoryId.equals(other.repositoryId) && moduleId.equals(other.moduleId);
    }

    @Override
    public int hashCode() {
        return repositoryId.hashCode() ^ moduleId.hashCode();
    }

        return f.equals(that.f) && g.equals(that.g);
      }
      return false;
    }

    @Override
    public int hashCode() {
      return f.hashCode() ^ g.hashCode();
    }

    @Override
    public String toString() {
      // TODO(cpovirk): maybe make this look like the method call does ("Functions.compose(...)")
      return g + "(" + f + ")";