import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public static <D extends PsiElement> Map<D, List<D>> factorDuplicates(D[] elements, TObjectHashingStrategy<D> strategy) {
  if (elements == null || elements.length == 0) return Collections.emptyMap();

  THashMap<D, List<D>> map = new THashMap<D, List<D>>(strategy);

  for (D element : elements) {
    List<D> list = map.get(element);
    if (list == null) {
      list = new ArrayList<D>();
    }
    list.add(element);
    map.put(element, list);
  }

  return map;
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public boolean isModified() {
  List<Compiler> selectedElements = myValidators.getMarkedElements();
  List<Compiler> markedValidators = getMarkedValidators();
  if (markedValidators.size() != selectedElements.size()) {
    return true;
  }
  Set<Compiler> set = new THashSet<Compiler>(selectedElements, new TObjectHashingStrategy<Compiler>() {
    public int computeHashCode(Compiler object) {
      return object.getDescription().hashCode();
    }

    public boolean equals(Compiler o1, Compiler o2) {
      return o1.getDescription().equals(o2.getDescription());
    }
  });
  return myConfiguration.VALIDATE_ON_BUILD != myValidateBox.isSelected() ||
      set.retainAll(markedValidators) ||
      myExcludedConfigurable.isModified();
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
@Nonnull
public static <K, V> MultiMap<K, V> createSet(final TObjectHashingStrategy strategy) {
  return new MultiMap<K, V>() {
    @Nonnull
    @Override
    protected Collection<V> createCollection() {
      return new SmartHashSet<V>();
    }

    @Nonnull
    @Override
    protected Collection<V> createEmptyCollection() {
      return Collections.emptySet();
    }

    @Nonnull
    @Override
    protected Map<K, Collection<V>> createMap() {
      return new THashMap<K, Collection<V>>(strategy);
    }
  };
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
void addAdoptedName(String name, boolean caseSensitive) {
  if (myAdoptedNames == null) {
    //noinspection unchecked
    myAdoptedNames = new THashSet<String>(0, caseSensitive ? TObjectHashingStrategy.CANONICAL : CaseInsensitiveStringHashingStrategy.INSTANCE);
  }
  myAdoptedNames.add(name);
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
@Test(timeout = TIMEOUT)
public void testKeysRemovedWhenIdentityStrategyIsUsed() {
  @SuppressWarnings("unchecked") ConcurrentWeakHashMap<Object, Object> map = new ConcurrentWeakHashMap<Object, Object>(TObjectHashingStrategy.IDENTITY);
  map.put(new Object(), new Object());

  do {
    tryGcSoftlyReachableObjects(); // sometimes weak references are not collected under linux, try to stress gc to force them
    System.gc();
  }
  while (!map.processQueue());
  map.put(this, this);
  assertEquals(1, map.underlyingMapSize());
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
@NotNull
public static <K, V> MultiMap<K, V> create(@NotNull final TObjectHashingStrategy<K> strategy) {
  return new MultiMap<K, V>() {
    @NotNull
    @Override
    protected Map<K, Collection<V>> createMap() {
      return new THashMap<K, Collection<V>>(strategy);
    }
  };
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public ConcurrentWeakKeySoftValueHashMap(int initialCapacity,
                                            float loadFactor,
                                            int concurrencyLevel,
                                            @NotNull final TObjectHashingStrategy<K> hashingStrategy) {
  myHashingStrategy = hashingStrategy;
  myMap = ContainerUtil.newConcurrentMap(initialCapacity, loadFactor, concurrencyLevel, ContainerUtil.<KeyReference<K,V>>canonicalStrategy());
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
WeakKey(@NotNull K k,
        @NotNull ValueReference<K, V> valueReference,
        @NotNull TObjectHashingStrategy<K> strategy,
        @NotNull ReferenceQueue<K> queue) {
  super(k, queue);
  myValueReference = valueReference;
  myHash = strategy.computeHashCode(k);
  myStrategy = strategy;
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public ConcurrentRefHashMap(int initialCapacity,
                            float loadFactor,
                            int concurrencyLevel,
                            @NotNull TObjectHashingStrategy<K> hashingStrategy) {
  myHashingStrategy = hashingStrategy == THIS ? this : hashingStrategy;
  myMap = ContainerUtil.<KeyReference<K, V>, V>newConcurrentMap(initialCapacity, loadFactor, concurrencyLevel, CANONICAL);
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public RefHashMap(@NotNull final TObjectHashingStrategy<K> hashingStrategy) {
  this(4, 0.8f, new TObjectHashingStrategy<Key<K>>() {
    @Override
    public int computeHashCode(final Key<K> object) {
      return hashingStrategy.computeHashCode(object.get());
    }

    @Override
    public boolean equals(final Key<K> o1, final Key<K> o2) {
      return hashingStrategy.equals(o1.get(), o2.get());
    }
  });
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
Node(int hash, K key, V val, Node<K, V> next, @NotNull TObjectHashingStrategy<K> hashingStrategy) {
  this.hash = hash;
  this.key = key;
  this.val = val;
  this.next = next;
  myHashingStrategy = hashingStrategy;
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel, @NotNull TObjectHashingStrategy<K> hashingStrategy) {
  if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0) {
    throw new IllegalArgumentException();
  }
  if (initialCapacity < concurrencyLevel)   // Use at least as many bins
  {
    initialCapacity = concurrencyLevel;   // as estimated threads
  }
  long size = (long)(1.0 + (long)initialCapacity / loadFactor);
  int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
  this.sizeCtl = cap;
  myHashingStrategy = hashingStrategy == THIS ? this : hashingStrategy;
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public static <K,V> StripedLockConcurrentHashMap<K,V> createWithStrategy(@NotNull final TObjectHashingStrategy<K> hashingStrategy, int initialCapacity) {
  return new StripedLockConcurrentHashMap<K, V>(initialCapacity){
    @Override
    protected TObjectHashingStrategy<K> getHashingStrategy() {
      return hashingStrategy;
    }
  };
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
@Override
public Iterable<LookupElement> classify(Iterable<LookupElement> source, final ProcessingContext context) {
  checkPrefixChanged(context);

  final Collection<List<LookupElement>> byWeight = buildMapByWeight(source, context).descendingMap().values();

  List<LookupElement> initialList = getInitialNoStatElements(source, context);

  //noinspection unchecked
  final THashSet<LookupElement> initialSet = new THashSet<LookupElement>(initialList, TObjectHashingStrategy.IDENTITY);
  final Condition<LookupElement> notInInitialList = new Condition<LookupElement>() {
    @Override
    public boolean value(LookupElement element) {
      return !initialSet.contains(element);
    }
  };

  return ContainerUtil.concat(initialList, new Iterable<LookupElement>() {
    @Override
    public Iterator<LookupElement> iterator() {
      return new FlatteningIterator<List<LookupElement>, LookupElement>(byWeight.iterator()) {
        @Override
        protected Iterator<LookupElement> createValueIterator(List<LookupElement> group) {
          return myNext.classify(ContainerUtil.findAll(group, notInInitialList), context).iterator();
        }
      };
    }
  });
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public void processChildren(@NotNull Processor<SliceUsage> processor) {
  final PsiElement element = ApplicationManager.getApplication().runReadAction(new Computable<PsiElement>() {
    @Override
    public PsiElement compute() {
      return getElement();
    }
  });
  ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
  indicator.checkCanceled();

  final Processor<SliceUsage> uniqueProcessor =
    new CommonProcessors.UniqueProcessor<SliceUsage>(processor, new TObjectHashingStrategy<SliceUsage>() {
      @Override
      public int computeHashCode(final SliceUsage object) {
        return object.getUsageInfo().hashCode();
      }

      @Override
      public boolean equals(final SliceUsage o1, final SliceUsage o2) {
        return o1.getUsageInfo().equals(o2.getUsageInfo());
      }
    });

  ApplicationManager.getApplication().runReadAction(new Runnable() {
    @Override
    public void run() {
      if (params.dataFlowToThis) {
        processUsagesFlownDownTo(element, uniqueProcessor);
      }
      else {
        processUsagesFlownFromThe(element, uniqueProcessor);
      }
    }
  });
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
static Set<Object> getPropertiesKeys(final PropertyReferenceBase propertyReference) {
  final Set<Object> variants = new THashSet<Object>(new TObjectHashingStrategy<Object>() {
    public int computeHashCode(final Object object) {
      if (object instanceof IProperty) {
        final String key = ((IProperty)object).getKey();
        return key == null ? 0 : key.hashCode();
      }
      else {
        return 0;
      }
    }

    public boolean equals(final Object o1, final Object o2) {
      return o1 instanceof IProperty && o2 instanceof IProperty &&
             Comparing.equal(((IProperty)o1).getKey(), ((IProperty)o2).getKey(), true);
    }
  });
  List<PropertiesFile> propertiesFileList = propertyReference.getPropertiesFiles();
  if (propertiesFileList == null) {
    PropertiesReferenceManager
      .getInstance(propertyReference.getElement().getProject()).processAllPropertiesFiles(new PropertiesFileProcessor() {
      @Override
      public boolean process(String baseName, PropertiesFile propertiesFile) {
        addVariantsFromFile(propertyReference, propertiesFile, variants);
        return true;
      }
    });
  }
  else {
    for (PropertiesFile propFile : propertiesFileList) {
      addVariantsFromFile(propertyReference, propFile, variants);
    }
  }
  return variants;
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public void processChildren(Processor<SliceUsage> processor) {
  final PsiElement element = getElement();
  ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
  indicator.checkCanceled();

  final Processor<SliceUsage> uniqueProcessor =
    new CommonProcessors.UniqueProcessor<SliceUsage>(processor, new TObjectHashingStrategy<SliceUsage>() {
      @Override
      public int computeHashCode(final SliceUsage object) {
        return object.getUsageInfo().hashCode();
      }

      @Override
      public boolean equals(final SliceUsage o1, final SliceUsage o2) {
        return o1.getUsageInfo().equals(o2.getUsageInfo());
      }
    });

  ApplicationManager.getApplication().runReadAction(new Runnable() {
    @Override
    public void run() {
      if (params.dataFlowToThis) {
        SliceUtil.processUsagesFlownDownTo(element, uniqueProcessor, SliceUsage.this, mySubstitutor);
      }
      else {
        SliceFUtil.processUsagesFlownFromThe(element, uniqueProcessor, SliceUsage.this);
      }
    }
  });
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
@NotNull
private static <K,V> TObjectHashingStrategy<Key<K, V>> convertKToKeyK(@NotNull final TObjectHashingStrategy<K> hashingStrategy) {
  return new TObjectHashingStrategy<Key<K, V>>() {
    @Override
    public int computeHashCode(final Key<K, V> object) {
      return hashingStrategy.computeHashCode(object.get());
    }

    @Override
    public boolean equals(final Key<K, V> o1, final Key<K, V> o2) {
      return hashingStrategy.equals(o1.get(), o2.get());
    }
  };
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel, TObjectHashingStrategy<K> hashingStrategy) {
  if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
    throw new IllegalArgumentException();

  if (concurrencyLevel > MAX_SEGMENTS)
    concurrencyLevel = MAX_SEGMENTS;

  // Find power-of-two sizes best matching arguments
  int sshift = 0;
  int ssize = 1;
  while (ssize < concurrencyLevel) {
    ++sshift;
    ssize <<= 1;
  }
  segmentShift = 12; // the middle of the hash is much more random that its HSB. Especially when we use TObjectHashingStrategy.CANONICAl as a hash provider
  segmentMask = ssize - 1;
  segments = new Segment[ssize];

  if (initialCapacity > MAXIMUM_CAPACITY)
    initialCapacity = MAXIMUM_CAPACITY;
  int c = initialCapacity / ssize;
  if (c * ssize < initialCapacity)
    ++c;
  int cap = 1;
  while (cap < c)
    cap <<= 1;

  hashingStrategy = hashingStrategy == null ? this : hashingStrategy;
  for (int i = 0; i < segments.length; ++i)
    segments[i] = new Segment<K,V>(cap, loadFactor,hashingStrategy);
  myHashingStrategy = hashingStrategy;
}
 

import gnu.trove.TObjectHashingStrategy; //导入依赖的package包/类
public void testKeysRemovedWhenIdentityStrategyIsUsed() {
  ConcurrentWeakHashMap<Object, Object> map = new ConcurrentWeakHashMap<Object, Object>(TObjectHashingStrategy.IDENTITY);
  map.put(new Object(), new Object());

  do {
    System.gc();
  }
  while (!map.processQueue());
  map.put(this, this);
  assertEquals(1, map.underlyingMapSize());
}