gnu.trove.TObjectHashingStrategy Java Examples

@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);
    }
  };
}
 

@Override
public void occurrence(@Nonnull final StubIndexKey indexKey, @Nonnull final Object value) {
  Map<Object, int[]> map = myResult.get(indexKey);
  if (map == null) {
    map = new THashMap<>((TObjectHashingStrategy<Object>)myHashingStrategyFunction.fun(indexKey));
    myResult.put(indexKey, map);
  }

  int[] list = map.get(value);
  if (list == null) {
    map.put(value, new int[]{myStubIdx});
  }
  else {
    int lastNonZero = ArrayUtil.lastIndexOfNot(list, 0);
    if (lastNonZero >= 0 && list[lastNonZero] == myStubIdx) {
      // second and subsequent occurrence calls for the same value are no op
      return;
    }
    int lastZero = lastNonZero + 1;

    if (lastZero == list.length) {
      list = ArrayUtil.realloc(list, Math.max(4, list.length << 1));
      map.put(value, list);
    }
    list[lastZero] = myStubIdx;
  }
}
 

@Nonnull
public static <K, V> MultiMap<K, V> create(@Nonnull final TObjectHashingStrategy<K> strategy) {
  return new MultiMap<K, V>() {
    @Nonnull
    @Override
    protected Map<K, Collection<V>> createMap() {
      return new THashMap<K, Collection<V>>(strategy);
    }
  };
}
 

private void processQueue(@Nonnull NewVirtualFileSystem fs, @Nonnull PersistentFS persistence) throws RefreshCancelledException {
  TObjectHashingStrategy<String> strategy = FilePathHashingStrategy.create(fs.isCaseSensitive());

  next:
  while (!myRefreshQueue.isEmpty()) {
    VirtualDirectoryImpl dir = (VirtualDirectoryImpl)myRefreshQueue.pullFirst();
    boolean fullSync = dir.allChildrenLoaded(), succeeded;

    do {
      myHelper.beginTransaction();
      try {
        succeeded = fullSync ? fullDirRefresh(fs, persistence, strategy, dir) : partialDirRefresh(fs, persistence, strategy, dir);
      }
      catch (InvalidVirtualFileAccessException e) {
        myHelper.endTransaction(false);
        continue next;
      }
      myHelper.endTransaction(succeeded);
      if (!succeeded && LOG.isTraceEnabled()) LOG.trace("retry: " + dir);
    }
    while (!succeeded);

    if (myIsRecursive) {
      dir.markClean();
    }
  }
}
 

public ObjectIntHashMap(int initialCapacity, @Nonnull TObjectHashingStrategy<K> strategy) {
  super(initialCapacity, strategy);
}
 

public SmartHashSet(int initialCapacity, float loadFactor, TObjectHashingStrategy<T> strategy) {
  super(initialCapacity, loadFactor, strategy);
}
 

RefHashMap(@Nonnull final TObjectHashingStrategy<? super K> hashingStrategy) {
  this(4, 0.8f, hashingStrategy);
}
 

static <K> boolean keyEqual(K k1, K k2, TObjectHashingStrategy<? super K> strategy) {
  return k1 == k2 || strategy.equals(k1, k2);
}
 

@Nonnull
public static TObjectHashingStrategy<CharSequence> createForCharSequence() {
  return SystemInfo.isFileSystemCaseSensitive ? CharSequenceHashingStrategy.CASE_SENSITIVE : CharSequenceHashingStrategy.CASE_INSENSITIVE;
}
 

@Nonnull
protected abstract <T> Key<T> createKey(@Nonnull T k, @Nonnull TObjectHashingStrategy<? super T> strategy, @Nonnull ReferenceQueue<? super T> q);
 

@Nonnull
public static <K, V> MultiMap<K, V> createSet() {
  return createSet(TObjectHashingStrategy.CANONICAL);
}
 

SoftValueHashMap(@Nonnull TObjectHashingStrategy<K> strategy) {
  super(strategy);
}
 

@Nonnull
public static TObjectHashingStrategy<String> create() {
  return create(SystemInfo.isFileSystemCaseSensitive);
}
 

public ObjectLongHashMap(int initialCapacity, @Nonnull TObjectHashingStrategy<K> strategy) {
  super(initialCapacity, strategy);
}
 

public Interner(@Nonnull TObjectHashingStrategy<T> strategy) {
  mySet = new OpenTHashSet<T>(strategy);
}
 

public SmartHashSet(int initialCapacity, TObjectHashingStrategy<T> strategy) {
  super(initialCapacity, strategy);
}
 

public SmartHashSet(int initialCapacity, float loadFactor, TObjectHashingStrategy<T> strategy) {
  super(initialCapacity, loadFactor, strategy);
}
 

@Override
@Nonnull
protected TObjectHashingStrategy<E> getStrategy() {
  return strategy;
}
 

ConcurrentRefHashMap(int initialCapacity, float loadFactor, int concurrencyLevel, @Nonnull TObjectHashingStrategy<? super K> hashingStrategy) {
  myHashingStrategy = hashingStrategy == THIS ? this : hashingStrategy;
  myMap = ContainerUtil.newConcurrentMap(initialCapacity, loadFactor, concurrencyLevel);
}
 

public SoftArrayHashMap(@Nonnull TObjectHashingStrategy<T> strategy) {
  myStrategy = strategy;
}
 

@Nonnull
@Contract(pure = true)
public static <K, V> ConcurrentMap<K, V> createConcurrentWeakMap(int initialCapacity, float loadFactor, int concurrencyLevel, @Nonnull TObjectHashingStrategy<K> hashingStrategy) {
  return Maps.newConcurrentWeakHashMap(initialCapacity, loadFactor, concurrencyLevel, hashingStrategy);
}
 

@Nonnull
@Contract(pure = true)
@Deprecated
public static <K, V> ConcurrentMap<K, V> createConcurrentSoftMap(int initialCapacity, float loadFactor, int concurrencyLevel, @Nonnull TObjectHashingStrategy<K> hashingStrategy) {
  return Maps.newConcurrentSoftHashMap(initialCapacity, loadFactor, concurrencyLevel, hashingStrategy);
}
 

@Nonnull
@Contract(pure = true)
public static <K, V> ConcurrentMap<K, V> createConcurrentWeakKeyWeakValueMap(@Nonnull TObjectHashingStrategy<K> strategy) {
  //noinspection deprecation
  return new ConcurrentWeakKeyWeakValueHashMap<K, V>(100, 0.75f, Runtime.getRuntime().availableProcessors(), strategy);
}
 

@Contract(value = "_, _, _ -> new", pure = true)
@Nonnull
@Deprecated
public static <K, V> Map<K, V> createWeakMap(int initialCapacity, float loadFactor, @Nonnull TObjectHashingStrategy<? super K> strategy) {
  return Maps.newWeakHashMap(initialCapacity, loadFactor, strategy);
}
 

@Nonnull
@Contract(pure = true)
@Deprecated
public static <K, V> ConcurrentMap<K, V> createConcurrentWeakKeySoftValueMap(int initialCapacity, float loadFactor, int concurrencyLevel, @Nonnull final TObjectHashingStrategy<K> hashingStrategy) {
  return Maps.newConcurrentWeakKeySoftValueHashMap(initialCapacity, loadFactor, concurrencyLevel, hashingStrategy);
}
 

public OpenTHashSet(final int initialCapacity, final TObjectHashingStrategy<T> strategy) {
  super(initialCapacity, strategy);
}
 

@Nonnull
@Contract(pure = true)
@Deprecated
public static <T> TObjectHashingStrategy<T> canonicalStrategy() {
  return ObjectHashingStrategies.canonicalStrategy();
}
 

@Nonnull
@Contract(pure = true)
public static <K, V> ConcurrentMap<K, V> createConcurrentSoftKeySoftValueMap(int initialCapacity, float loadFactor, int concurrencyLevel, @Nonnull final TObjectHashingStrategy<K> hashingStrategy) {
  return new ConcurrentSoftKeySoftValueHashMap<K, V>(initialCapacity, loadFactor, concurrencyLevel, hashingStrategy);
}
 

public Enumerator(int expectNumber, TObjectHashingStrategy<T> strategy) {
  myNumbers = new TObjectIntHashMap<T>(expectNumber, strategy);
}
 

public OrderedSet(@Nonnull TObjectHashingStrategy<T> hashingStrategy) {
  this(hashingStrategy, 4);
}