From 610c31837dc7dad62ffa2ad51c53c9ec5b8a0eff Mon Sep 17 00:00:00 2001 From: Eugene Zhuravlev Date: Fri, 29 Nov 2013 17:36:12 +0100 Subject: [PATCH] all code in "util" module to create CHM implementation via dedicated factory (see IDEA-116404 Java code compilation does not work with IBM JDK) --- .../com/intellij/openapi/util/IconLoader.java | 4 +- .../util/SharedProcessingContext.java | 4 +- .../util/containers/ConcurrentClassMap.java | 2 +- .../util/containers/ConcurrentFactoryMap.java | 23 +----- .../util/containers/ConcurrentHashSet.java | 6 +- .../util/containers/ConcurrentMapFactory.java | 80 +++++++++++++++++++ .../ConcurrentMostlySingularMultiMap.java | 2 +- .../util/containers/ConcurrentMultiMap.java | 2 +- .../util/containers/ConcurrentRefHashMap.java | 4 +- .../containers/ConcurrentRefValueHashMap.java | 8 +- .../util/containers/ContainerUtil.java | 2 +- .../util/io/storage/RefCountingStorage.java | 4 +- .../util/pico/DefaultPicoContainer.java | 6 +- 13 files changed, 103 insertions(+), 44 deletions(-) create mode 100644 platform/util/src/com/intellij/util/containers/ConcurrentMapFactory.java diff --git a/platform/util/src/com/intellij/openapi/util/IconLoader.java b/platform/util/src/com/intellij/openapi/util/IconLoader.java index d0ce5bc9f86f..a5a30bc0ca65 100644 --- a/platform/util/src/com/intellij/openapi/util/IconLoader.java +++ b/platform/util/src/com/intellij/openapi/util/IconLoader.java @@ -22,7 +22,7 @@ import com.intellij.util.ConcurrencyUtil; import com.intellij.util.ImageLoader; import com.intellij.util.ReflectionUtil; import com.intellij.util.RetinaImage; -import com.intellij.util.containers.ConcurrentHashMap; +import com.intellij.util.containers.ConcurrentMapFactory; import com.intellij.util.containers.WeakHashMap; import com.intellij.util.ui.UIUtil; import org.jetbrains.annotations.NonNls; @@ -49,7 +49,7 @@ public final class IconLoader { private static boolean USE_DARK_ICONS = UIUtil.isUnderDarcula(); @SuppressWarnings("MismatchedQueryAndUpdateOfCollection") - private static final ConcurrentMap ourIconsCache = new ConcurrentHashMap(100, 0.9f,2); + private static final ConcurrentMap ourIconsCache = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(100, 0.9f, 2); /** * This cache contains mapping between icons and disabled icons. diff --git a/platform/util/src/com/intellij/util/SharedProcessingContext.java b/platform/util/src/com/intellij/util/SharedProcessingContext.java index 16f1c8108cef..14c5b9bb7927 100644 --- a/platform/util/src/com/intellij/util/SharedProcessingContext.java +++ b/platform/util/src/com/intellij/util/SharedProcessingContext.java @@ -1,7 +1,7 @@ package com.intellij.util; import com.intellij.openapi.util.Key; -import com.intellij.util.containers.ConcurrentHashMap; +import com.intellij.util.containers.ConcurrentMapFactory; import gnu.trove.THashMap; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; @@ -13,7 +13,7 @@ import java.util.Map; * @author peter */ public class SharedProcessingContext { - private final Map myMap = new ConcurrentHashMap(); + private final Map myMap = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); public Object get(@NotNull @NonNls final String key) { return myMap.get(key); diff --git a/platform/util/src/com/intellij/util/containers/ConcurrentClassMap.java b/platform/util/src/com/intellij/util/containers/ConcurrentClassMap.java index 813f495f1c8b..760e447f9f32 100644 --- a/platform/util/src/com/intellij/util/containers/ConcurrentClassMap.java +++ b/platform/util/src/com/intellij/util/containers/ConcurrentClassMap.java @@ -20,6 +20,6 @@ package com.intellij.util.containers; */ public class ConcurrentClassMap extends ClassMap { public ConcurrentClassMap() { - super(new ConcurrentHashMap()); + super(ConcurrentMapFactory.DEFAULT_FACTORY.createMap()); } } diff --git a/platform/util/src/com/intellij/util/containers/ConcurrentFactoryMap.java b/platform/util/src/com/intellij/util/containers/ConcurrentFactoryMap.java index d0b2622d58be..839c04dd049e 100644 --- a/platform/util/src/com/intellij/util/containers/ConcurrentFactoryMap.java +++ b/platform/util/src/com/intellij/util/containers/ConcurrentFactoryMap.java @@ -15,8 +15,6 @@ */ package com.intellij.util.containers; -import com.intellij.openapi.util.SystemInfo; - import java.util.Map; /** @@ -24,27 +22,8 @@ import java.util.Map; */ public abstract class ConcurrentFactoryMap extends FactoryMap { - private interface MapFactory { - int DEFAULT_CONCURRENCY_LEVEL = Runtime.getRuntime().availableProcessors(); - - MapFactory V8_MAP_FACTORY = new MapFactory() { - public Map createMap() { - return new ConcurrentHashMap(); - } - }; - MapFactory DEFAULT_MAP_FACTORY = new MapFactory() { - public Map createMap() { - return new java.util.concurrent.ConcurrentHashMap(16, 0.75f, DEFAULT_CONCURRENCY_LEVEL); - } - }; - - Map createMap(); - } - - private static final MapFactory ourMapFactory = SystemInfo.isOracleJvm || SystemInfo.isAppleJvm? MapFactory.V8_MAP_FACTORY : MapFactory.DEFAULT_MAP_FACTORY; - @Override protected Map createMap() { - return ourMapFactory.createMap(); + return ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); } } diff --git a/platform/util/src/com/intellij/util/containers/ConcurrentHashSet.java b/platform/util/src/com/intellij/util/containers/ConcurrentHashSet.java index 59a22408a1a0..9fa9a3273513 100644 --- a/platform/util/src/com/intellij/util/containers/ConcurrentHashSet.java +++ b/platform/util/src/com/intellij/util/containers/ConcurrentHashSet.java @@ -28,13 +28,13 @@ public class ConcurrentHashSet implements Set { private final ConcurrentMap map; public ConcurrentHashSet(int initialCapacity) { - map = new ConcurrentHashMap(initialCapacity); + map = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(initialCapacity); } public ConcurrentHashSet() { - map = new ConcurrentHashMap(); + map = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); } public ConcurrentHashSet(@NotNull TObjectHashingStrategy hashingStrategy) { - map = new ConcurrentHashMap(hashingStrategy); + map = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(hashingStrategy); } @Override diff --git a/platform/util/src/com/intellij/util/containers/ConcurrentMapFactory.java b/platform/util/src/com/intellij/util/containers/ConcurrentMapFactory.java new file mode 100644 index 000000000000..ed351abbacbb --- /dev/null +++ b/platform/util/src/com/intellij/util/containers/ConcurrentMapFactory.java @@ -0,0 +1,80 @@ +/* + * Copyright 2000-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.util.containers; + +import com.intellij.openapi.util.SystemInfo; +import gnu.trove.TObjectHashingStrategy; +import org.jetbrains.annotations.NotNull; + +import java.util.concurrent.ConcurrentMap; + +public interface ConcurrentMapFactory { + int DEFAULT_CONCURRENCY_LEVEL = Runtime.getRuntime().availableProcessors(); + + ConcurrentMapFactory V8_MAP_FACTORY = new ConcurrentMapFactory() { + public ConcurrentMap createMap() { + return new ConcurrentHashMap(); + } + + public ConcurrentMap createMap(int initialCapacity) { + return new ConcurrentHashMap(initialCapacity); + } + + public ConcurrentMap createMap(TObjectHashingStrategy hashStrategy) { + return new ConcurrentHashMap(hashStrategy); + } + + public ConcurrentMap createMap(int initialCapacity, float loadFactor, int concurrencyLevel) { + return new ConcurrentHashMap(initialCapacity, loadFactor, concurrencyLevel); + } + + public ConcurrentMap createMap(int initialCapacity, float loadFactor, int concurrencyLevel, @NotNull TObjectHashingStrategy hashingStrategy) { + return new ConcurrentHashMap(initialCapacity, loadFactor, concurrencyLevel, hashingStrategy); + } + }; + + ConcurrentMapFactory PLATFORM_MAP_FACTORY = new ConcurrentMapFactory() { + public ConcurrentMap createMap() { + return createMap(16, 0.75f, DEFAULT_CONCURRENCY_LEVEL); + } + + public ConcurrentMap createMap(int initialCapacity) { + return new java.util.concurrent.ConcurrentHashMap(initialCapacity); + } + + public ConcurrentMap createMap(TObjectHashingStrategy hashStrategy) { + // ignoring strategy parameter, because it is not supported by this implementation + return createMap(); + } + + public ConcurrentMap createMap(int initialCapacity, float loadFactor, int concurrencyLevel) { + return new java.util.concurrent.ConcurrentHashMap(initialCapacity, loadFactor, concurrencyLevel); + } + + public ConcurrentMap createMap(int initialCapacity, float loadFactor, int concurrencyLevel, @NotNull TObjectHashingStrategy hashingStrategy) { + // ignoring strategy parameter, because it is not supported by this implementation + return createMap(initialCapacity, loadFactor, concurrencyLevel); + } + }; + + ConcurrentMapFactory DEFAULT_FACTORY = SystemInfo.isOracleJvm || SystemInfo.isAppleJvm? V8_MAP_FACTORY : PLATFORM_MAP_FACTORY; + + ConcurrentMap createMap(); + ConcurrentMap createMap(int initialCapacity); + ConcurrentMap createMap(TObjectHashingStrategy hashStrategy); + ConcurrentMap createMap(int initialCapacity, float loadFactor, int concurrencyLevel); + ConcurrentMap createMap(int initialCapacity, float loadFactor, int concurrencyLevel, TObjectHashingStrategy hashStrategy); +} diff --git a/platform/util/src/com/intellij/util/containers/ConcurrentMostlySingularMultiMap.java b/platform/util/src/com/intellij/util/containers/ConcurrentMostlySingularMultiMap.java index b467007c99bd..b7d787a4c4e5 100644 --- a/platform/util/src/com/intellij/util/containers/ConcurrentMostlySingularMultiMap.java +++ b/platform/util/src/com/intellij/util/containers/ConcurrentMostlySingularMultiMap.java @@ -28,7 +28,7 @@ public class ConcurrentMostlySingularMultiMap extends MostlySingularMultiM @NotNull @Override protected Map createMap() { - return new ConcurrentHashMap(); + return ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); } @Override diff --git a/platform/util/src/com/intellij/util/containers/ConcurrentMultiMap.java b/platform/util/src/com/intellij/util/containers/ConcurrentMultiMap.java index c6e5616d67a4..419391576e06 100644 --- a/platform/util/src/com/intellij/util/containers/ConcurrentMultiMap.java +++ b/platform/util/src/com/intellij/util/containers/ConcurrentMultiMap.java @@ -25,7 +25,7 @@ import java.util.Map; public class ConcurrentMultiMap extends MultiMap { @Override protected Map> createMap() { - return new ConcurrentHashMap>(); + return ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); } @Override diff --git a/platform/util/src/com/intellij/util/containers/ConcurrentRefHashMap.java b/platform/util/src/com/intellij/util/containers/ConcurrentRefHashMap.java index 469342e0872e..efbad822d5c3 100644 --- a/platform/util/src/com/intellij/util/containers/ConcurrentRefHashMap.java +++ b/platform/util/src/com/intellij/util/containers/ConcurrentRefHashMap.java @@ -36,7 +36,7 @@ import java.util.concurrent.ConcurrentMap; */ abstract class ConcurrentRefHashMap extends AbstractMap implements ConcurrentMap, TObjectHashingStrategy { protected final ReferenceQueue myReferenceQueue = new ReferenceQueue(); - private final ConcurrentHashMap, V> myMap; // hashing strategy must be canonical, we compute corresponding hash codes using our own myHashingStrategy + private final ConcurrentMap, V> myMap; // hashing strategy must be canonical, we compute corresponding hash codes using our own myHashingStrategy @NotNull private final TObjectHashingStrategy myHashingStrategy; @@ -149,7 +149,7 @@ abstract class ConcurrentRefHashMap extends AbstractMap implements C int concurrencyLevel, @NotNull TObjectHashingStrategy hashingStrategy) { myHashingStrategy = hashingStrategy == THIS ? this : hashingStrategy; - myMap = new ConcurrentHashMap, V>(initialCapacity, loadFactor, concurrencyLevel, CANONICAL); + myMap = ConcurrentMapFactory.DEFAULT_FACTORY., V>createMap(initialCapacity, loadFactor, concurrencyLevel, CANONICAL); } @Override diff --git a/platform/util/src/com/intellij/util/containers/ConcurrentRefValueHashMap.java b/platform/util/src/com/intellij/util/containers/ConcurrentRefValueHashMap.java index e3888277342f..b01438d88911 100644 --- a/platform/util/src/com/intellij/util/containers/ConcurrentRefValueHashMap.java +++ b/platform/util/src/com/intellij/util/containers/ConcurrentRefValueHashMap.java @@ -26,7 +26,7 @@ import java.util.*; import java.util.concurrent.ConcurrentMap; abstract class ConcurrentRefValueHashMap implements ConcurrentMap { - private final ConcurrentHashMap> myMap; + private final ConcurrentMap> myMap; protected final ReferenceQueue myQueue = new ReferenceQueue(); public ConcurrentRefValueHashMap(@NotNull Map map) { @@ -35,18 +35,18 @@ abstract class ConcurrentRefValueHashMap implements ConcurrentMap { } public ConcurrentRefValueHashMap() { - myMap = new ConcurrentHashMap>(); + myMap = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); } public ConcurrentRefValueHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) { - myMap = new ConcurrentHashMap>(initialCapacity, loadFactor, concurrencyLevel); + myMap = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(initialCapacity, loadFactor, concurrencyLevel); } public ConcurrentRefValueHashMap(int initialCapacity, float loadFactor, int concurrencyLevel, @NotNull TObjectHashingStrategy hashingStrategy) { - myMap = new ConcurrentHashMap>(initialCapacity, loadFactor, concurrencyLevel, hashingStrategy); + myMap = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(initialCapacity, loadFactor, concurrencyLevel, hashingStrategy); } protected interface MyValueReference { diff --git a/platform/util/src/com/intellij/util/containers/ContainerUtil.java b/platform/util/src/com/intellij/util/containers/ContainerUtil.java index fc6c29e3f93d..410efc18790f 100644 --- a/platform/util/src/com/intellij/util/containers/ContainerUtil.java +++ b/platform/util/src/com/intellij/util/containers/ContainerUtil.java @@ -299,7 +299,7 @@ public class ContainerUtil extends ContainerUtilRt { @NotNull public static ConcurrentMap newConcurrentMap() { - return new ConcurrentHashMap(); + return ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); } @NotNull diff --git a/platform/util/src/com/intellij/util/io/storage/RefCountingStorage.java b/platform/util/src/com/intellij/util/io/storage/RefCountingStorage.java index 501e5e404408..bd6674e0c1c7 100644 --- a/platform/util/src/com/intellij/util/io/storage/RefCountingStorage.java +++ b/platform/util/src/com/intellij/util/io/storage/RefCountingStorage.java @@ -24,7 +24,7 @@ import com.intellij.openapi.util.io.ByteSequence; import com.intellij.openapi.util.io.StreamUtil; import com.intellij.util.ConcurrencyUtil; import com.intellij.util.IncorrectOperationException; -import com.intellij.util.containers.ConcurrentHashMap; +import com.intellij.util.containers.ConcurrentMapFactory; import com.intellij.util.io.PagePool; import com.intellij.util.io.UnsyncByteArrayInputStream; @@ -39,7 +39,7 @@ import java.util.zip.Inflater; import java.util.zip.InflaterInputStream; public class RefCountingStorage extends AbstractStorage { - private final Map> myPendingWriteRequests = new ConcurrentHashMap>(); + private final Map> myPendingWriteRequests = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); private int myPendingWriteRequestsSize; private final ThreadPoolExecutor myPendingWriteRequestsExecutor = new ThreadPoolExecutor(1, 1, Long.MAX_VALUE, TimeUnit.DAYS, new LinkedBlockingQueue(), ConcurrencyUtil.newNamedThreadFactory("RefCountingStorage write content helper")); diff --git a/platform/util/src/com/intellij/util/pico/DefaultPicoContainer.java b/platform/util/src/com/intellij/util/pico/DefaultPicoContainer.java index 631b381ab505..a88581382217 100644 --- a/platform/util/src/com/intellij/util/pico/DefaultPicoContainer.java +++ b/platform/util/src/com/intellij/util/pico/DefaultPicoContainer.java @@ -16,7 +16,7 @@ package com.intellij.util.pico; import com.intellij.util.ReflectionCache; -import com.intellij.util.containers.ConcurrentHashMap; +import com.intellij.util.containers.ConcurrentMapFactory; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.containers.FList; import org.jetbrains.annotations.NotNull; @@ -34,9 +34,9 @@ public class DefaultPicoContainer implements MutablePicoContainer, Serializable private final PicoContainer parent; private final Set children = new HashSet(); - private final Map componentKeyToAdapterCache = new ConcurrentHashMap(); + private final Map componentKeyToAdapterCache = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); private final LinkedHashSetWrapper componentAdapters = new LinkedHashSetWrapper(); - private final Map classNameToAdapter = new ConcurrentHashMap(); + private final Map classNameToAdapter = ConcurrentMapFactory.DEFAULT_FACTORY.createMap(); private final AtomicReference> nonAssignableComponentAdapters = new AtomicReference>(FList.emptyList()); public DefaultPicoContainer(@NotNull ComponentAdapterFactory componentAdapterFactory, PicoContainer parent) {