package edu.stanford.nlp.util;
import edu.stanford.nlp.util.logging.Redwood;
import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;
import edu.stanford.nlp.util.concurrent.SynchronizedInterner;
/**
* A collection of utilities to make dealing with Java generics less
* painful and verbose. For example, rather than declaring
*
* <pre>
* {@code Map<String,ClassicCounter<List<String>>> = new HashMap<String,ClassicCounter<List<String>>>()}
* </pre>
*
* you just call <code>Generics.newHashMap()</code>:
*
* <pre>
* {@code Map<String,ClassicCounter<List<String>>> = Generics.newHashMap()}
* </pre>
*
* Java type-inference will almost always just <em>do the right thing</em>
* (every once in a while, the compiler will get confused before you do,
* so you might still occasionally have to specify the appropriate types).
*
* This class is based on the examples in Brian Goetz's article
* <a href="http://www.ibm.com/developerworks/library/j-jtp02216.html">Java
* theory and practice: The pseudo-typedef antipattern</a>.
*
* @author Ilya Sherman
*/
public class Generics {
/** A logger for this class */
private static Redwood.RedwoodChannels log = Redwood.channels(Generics.class);
private Generics() {} // static class
/* Collections */
public static <E> ArrayList<E> newArrayList() {
return new ArrayList<>();
}
public static <E> ArrayList<E> newArrayList(int size) {
return new ArrayList<>(size);
}
public static <E> ArrayList<E> newArrayList(Collection<? extends E> c) {
return new ArrayList<>(c);
}
public static <E> LinkedList<E> newLinkedList() {
return new LinkedList<>();
}
public static <E> LinkedList<E> newLinkedList(Collection<? extends E> c) {
return new LinkedList<>(c);
}
public static <E> Stack<E> newStack() {
return new Stack<>();
}
public static <E> BinaryHeapPriorityQueue<E> newBinaryHeapPriorityQueue() {
return new BinaryHeapPriorityQueue<>();
}
public static <E> TreeSet<E> newTreeSet() {
return new TreeSet<>();
}
public static <E> TreeSet<E> newTreeSet(Comparator<? super E> comparator) {
return new TreeSet<>(comparator);
}
public static <E> TreeSet<E> newTreeSet(SortedSet<E> s) {
return new TreeSet<>(s);
}
public static final String HASH_SET_PROPERTY = "edu.stanford.nlp.hashset.impl";
public static final String HASH_SET_CLASSNAME = System.getProperty(HASH_SET_PROPERTY);
private static final Class<?> HASH_SET_CLASS = getHashSetClass();
private static final Constructor HASH_SET_SIZE_CONSTRUCTOR = getHashSetSizeConstructor();
private static final Constructor HASH_SET_COLLECTION_CONSTRUCTOR = getHashSetCollectionConstructor();
private static Class getHashSetClass() {
try {
if (HASH_SET_CLASSNAME == null) {
return HashSet.class;
} else {
return Class.forName(HASH_SET_CLASSNAME);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// must be called after HASH_SET_CLASS is defined
private static Constructor getHashSetSizeConstructor() {
try {
return HASH_SET_CLASS.getConstructor(Integer.TYPE);
} catch (Exception e) {
log.info("Warning: could not find a constructor for objects of " + HASH_SET_CLASS + " which takes an integer argument. Will use the no argument constructor instead.");
}
return null;
}
// must be called after HASH_SET_CLASS is defined
private static Constructor getHashSetCollectionConstructor() {
try {
return HASH_SET_CLASS.getConstructor(Collection.class);
} catch (Exception e) {
throw new RuntimeException("Error: could not find a constructor for objects of " + HASH_SET_CLASS + " which takes an existing collection argument.", e);
}
}
public static <E> Set<E> newHashSet() {
try {
return ErasureUtils.uncheckedCast(HASH_SET_CLASS.newInstance());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static <E> Set<E> newHashSet(int initialCapacity) {
if (HASH_SET_SIZE_CONSTRUCTOR == null) {
return newHashSet();
}
try {
return ErasureUtils.uncheckedCast(HASH_SET_SIZE_CONSTRUCTOR.newInstance(initialCapacity));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static <E> Set<E> newHashSet(Collection<? extends E> c) {
try {
return ErasureUtils.uncheckedCast(HASH_SET_COLLECTION_CONSTRUCTOR.newInstance(c));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static final String HASH_MAP_PROPERTY = "edu.stanford.nlp.hashmap.impl";
public static final String HASH_MAP_CLASSNAME = System.getProperty(HASH_MAP_PROPERTY);
private static final Class<?> HASH_MAP_CLASS = getHashMapClass();
private static final Constructor HASH_MAP_SIZE_CONSTRUCTOR = getHashMapSizeConstructor();
private static final Constructor HASH_MAP_FROM_MAP_CONSTRUCTOR = getHashMapFromMapConstructor();
private static Class getHashMapClass() {
try {
if (HASH_MAP_CLASSNAME == null) {
return HashMap.class;
} else {
return Class.forName(HASH_MAP_CLASSNAME);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// must be called after HASH_MAP_CLASS is defined
private static Constructor getHashMapSizeConstructor() {
try {
return HASH_MAP_CLASS.getConstructor(Integer.TYPE);
} catch (Exception e) {
log.info("Warning: could not find a constructor for objects of " + HASH_MAP_CLASS + " which takes an integer argument. Will use the no argument constructor instead.");
}
return null;
}
// must be called after HASH_MAP_CLASS is defined
private static Constructor getHashMapFromMapConstructor() {
try {
return HASH_MAP_CLASS.getConstructor(Map.class);
} catch (Exception e) {
throw new RuntimeException("Error: could not find a constructor for objects of " + HASH_MAP_CLASS + " which takes an existing Map argument.", e);
}
}
/* Maps */
public static <K,V> Map<K,V> newHashMap() {
try {
return ErasureUtils.uncheckedCast(HASH_MAP_CLASS.newInstance());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static <K,V> Map<K,V> newHashMap(int initialCapacity) {
if (HASH_MAP_SIZE_CONSTRUCTOR == null) {
return newHashMap();
}
try {
return ErasureUtils.uncheckedCast(HASH_MAP_SIZE_CONSTRUCTOR.newInstance(initialCapacity));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static <K,V> Map<K,V> newHashMap(Map<? extends K,? extends V> m) {
try {
return ErasureUtils.uncheckedCast(HASH_MAP_FROM_MAP_CONSTRUCTOR.newInstance(m));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static <K,V> IdentityHashMap<K,V> newIdentityHashMap() {
return new IdentityHashMap<>();
}
public static <K> Set<K> newIdentityHashSet() {
return Collections.newSetFromMap(Generics.<K, Boolean>newIdentityHashMap());
}
public static <K,V> WeakHashMap<K,V> newWeakHashMap() {
return new WeakHashMap<>();
}
public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap() {
return new ConcurrentHashMap<>();
}
public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap(int initialCapacity) {
return new ConcurrentHashMap<>(initialCapacity);
}
public static <K,V> ConcurrentHashMap<K,V> newConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
return new ConcurrentHashMap<>(initialCapacity, loadFactor, concurrencyLevel);
}
public static <K,V> TreeMap<K,V> newTreeMap() {
return new TreeMap<>();
}
public static <E> Index<E> newIndex() {
return new HashIndex<>();
}
public static <E> Set<E> newConcurrentHashSet() {
return Collections.newSetFromMap(new ConcurrentHashMap<>());
}
public static <E> Set<E> newConcurrentHashSet(Set<E> set) {
Set<E> ret = Collections.newSetFromMap(new ConcurrentHashMap<>());
ret.addAll(set);
return ret;
}
/* Other */
public static <T1,T2> Pair<T1,T2> newPair(T1 first, T2 second) {
return new Pair<>(first, second);
}
public static <T1,T2, T3> Triple<T1,T2, T3> newTriple(T1 first, T2 second, T3 third) {
return new Triple<>(first, second, third);
}
public static <T> Interner<T> newInterner() {
return new Interner<>();
}
public static <T> SynchronizedInterner<T> newSynchronizedInterner(Interner<T> interner) {
return new SynchronizedInterner<>(interner);
}
public static <T> SynchronizedInterner<T> newSynchronizedInterner(Interner<T> interner,
Object mutex) {
return new SynchronizedInterner<>(interner, mutex);
}
public static <T> WeakReference<T> newWeakReference(T referent) {
return new WeakReference<>(referent);
}
}