package org.python.util;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
/**
* Static methods to make instances of collections with their generic types inferred from what
* they're being assigned to. The idea is stolen from Sets, Lists and
* Maps from Google
* Collections.
*/
public class Generic {
/**
* Our default ConcurrentHashMap sizes. Only concurreny level differs from
* ConcurrentHashMap's defaults: it's significantly lower to reduce allocation cost.
*/
public static final int CHM_INITIAL_CAPACITY = 16;
public static final float CHM_LOAD_FACTOR = 0.75f;
public static final int CHM_CONCURRENCY_LEVEL = 2;
/**
* Makes a List with its generic type inferred from whatever it's being assigned to.
*/
public static List list() {
return new ArrayList();
}
/**
* Makes a List with its generic type inferred from whatever it's being assigned to.
* Sets initial capacity accordingly.
*/
public static List list(int capacity) {
return new ArrayList(capacity);
}
/**
* Makes a List with its generic type inferred from whatever it's being assigned to filled with
* the items in contents.
*/
@SafeVarargs
public static List list(U... contents) {
List l = new ArrayList(contents.length);
for (T t : contents) {
l.add(t);
}
return l;
}
/**
* Makes a Map using generic types inferred from whatever this is being assigned to.
*/
public static Map map() {
return new HashMap();
}
/**
* Makes an IdentityHashMap using generic types inferred from whatever this is being
* assigned to.
*/
public static Map identityHashMap() {
return new IdentityHashMap();
}
/**
* Makes an IdentityHashMap using generic types inferred from whatever this is being
* assigned to.
* Sets initial capacity accordingly.
*/
public static Map identityHashMap(int capacity) {
return new IdentityHashMap(capacity);
}
/**
* Makes a ConcurrentMap using generic types inferred from whatever this is being
* assigned to.
*/
public static ConcurrentMap concurrentMap() {
return new ConcurrentHashMap(CHM_INITIAL_CAPACITY, CHM_LOAD_FACTOR,
CHM_CONCURRENCY_LEVEL);
}
/**
* Makes a Set using the generic type inferred from whatever this is being assigned to.
*/
public static Set set() {
return new HashSet();
}
/**
* Makes a LinkedHashSet using the generic type inferred from whatever this is being assigned to.
*/
public static Set linkedHashSet() {
return new LinkedHashSet();
}
/**
* Makes a LinkedHashSet using the generic type inferred from whatever this is being assigned to.
* Sets initial capacity accordingly.
*/
public static Set linkedHashSet(int capacity) {
return new LinkedHashSet(capacity);
}
/**
* Makes a Set using the generic type inferred from whatever this is being assigned to filled
* with the items in contents.
*/
@SafeVarargs
public static Set set(U... contents) {
Set s = new HashSet(contents.length);
for (U u : contents) {
s.add(u);
}
return s;
}
/**
* Makes a Set, ensuring safe concurrent operations, using generic types inferred from
* whatever this is being assigned to.
*/
public static Set concurrentSet() {
return Collections.newSetFromMap(Generic.concurrentMap());
}
}