/** * Returns the platform preferred implementation of an insertion ordered map based on a hash * table. */ static <K, V> Map<K, V> newLinkedHashMapWithExpectedSize(int expectedSize) { return Maps.newLinkedHashMapWithExpectedSize(expectedSize); }
@Override public Map<C, V> get() { return Maps.newLinkedHashMapWithExpectedSize(expectedSize); }
private LinkedHashMultiset(int distinctElements) { super(Maps.<E, Count>newLinkedHashMapWithExpectedSize(distinctElements)); }
@Override public Map<C, V> get() { return Maps.newLinkedHashMapWithExpectedSize(expectedSize); }
/** * Returns the platform preferred implementation of an insertion ordered map based on a hash * table. */ static <K, V> Map<K, V> newLinkedHashMapWithExpectedSize(int expectedSize) { return Maps.newLinkedHashMapWithExpectedSize(expectedSize); }
@Override public Map<C, V> get() { return Maps.newLinkedHashMapWithExpectedSize(expectedSize); }
private LinkedHashMultiset(int distinctElements) { super(Maps.<E, Count>newLinkedHashMapWithExpectedSize(distinctElements)); }
/** Returns an empty mutable map whose keys will respect this {@link ElementOrder}. */ <K extends T, V> Map<K, V> createMap(int expectedSize) { switch (type) { case UNORDERED: return Maps.newHashMapWithExpectedSize(expectedSize); case INSERTION: return Maps.newLinkedHashMapWithExpectedSize(expectedSize); case SORTED: return Maps.newTreeMap(comparator()); default: throw new AssertionError(); } }
/** Returns an empty mutable map whose keys will respect this {@link ElementOrder}. */ <K extends T, V> Map<K, V> createMap(int expectedSize) { switch (type) { case UNORDERED: return Maps.newHashMapWithExpectedSize(expectedSize); case INSERTION: return Maps.newLinkedHashMapWithExpectedSize(expectedSize); case SORTED: return Maps.newTreeMap(comparator()); default: throw new AssertionError(); } }
/** Returns an empty mutable map whose keys will respect this {@link ElementOrder}. */ <K extends T, V> Map<K, V> createMap(int expectedSize) { switch (type) { case UNORDERED: return Maps.newHashMapWithExpectedSize(expectedSize); case INSERTION: return Maps.newLinkedHashMapWithExpectedSize(expectedSize); case SORTED: return Maps.newTreeMap(comparator()); default: throw new AssertionError(); } }
/** Same test as above but for newLinkedHashMapWithExpectedSize */ @GwtIncompatible // reflection @AndroidIncompatible // relies on assumptions about OpenJDK public void testNewLinkedHashMapWithExpectedSize_wontGrow() throws Exception { assertTrue(bucketsOf(Maps.newLinkedHashMapWithExpectedSize(0)) <= 1); for (int size = 1; size < 200; size++) { assertWontGrow( size, Maps.newLinkedHashMapWithExpectedSize(size), Maps.newLinkedHashMapWithExpectedSize(size)); } }
/** * Creates an empty {@code HashBasedTable} with the specified map sizes. * * @param expectedRows the expected number of distinct row keys * @param expectedCellsPerRow the expected number of column key / value mappings in each row * @throws IllegalArgumentException if {@code expectedRows} or {@code expectedCellsPerRow} is * negative */ public static <R, C, V> HashBasedTable<R, C, V> create( int expectedRows, int expectedCellsPerRow) { checkNonnegative(expectedCellsPerRow, "expectedCellsPerRow"); Map<R, Map<C, V>> backingMap = Maps.newLinkedHashMapWithExpectedSize(expectedRows); return new HashBasedTable<>(backingMap, new Factory<C, V>(expectedCellsPerRow)); }
/** * Creates an empty {@code HashBasedTable} with the specified map sizes. * * @param expectedRows the expected number of distinct row keys * @param expectedCellsPerRow the expected number of column key / value mappings in each row * @throws IllegalArgumentException if {@code expectedRows} or {@code expectedCellsPerRow} is * negative */ public static <R, C, V> HashBasedTable<R, C, V> create( int expectedRows, int expectedCellsPerRow) { checkNonnegative(expectedCellsPerRow, "expectedCellsPerRow"); Map<R, Map<C, V>> backingMap = Maps.newLinkedHashMapWithExpectedSize(expectedRows); return new HashBasedTable<>(backingMap, new Factory<C, V>(expectedCellsPerRow)); }
/** * Creates an empty {@code HashBasedTable} with the specified map sizes. * * @param expectedRows the expected number of distinct row keys * @param expectedCellsPerRow the expected number of column key / value mappings in each row * @throws IllegalArgumentException if {@code expectedRows} or {@code expectedCellsPerRow} is * negative */ public static <R, C, V> HashBasedTable<R, C, V> create( int expectedRows, int expectedCellsPerRow) { checkNonnegative(expectedCellsPerRow, "expectedCellsPerRow"); Map<R, Map<C, V>> backingMap = Maps.newLinkedHashMapWithExpectedSize(expectedRows); return new HashBasedTable<>(backingMap, new Factory<C, V>(expectedCellsPerRow)); }
final Map<Future<Boolean>, Path> moveFutures = Maps.newLinkedHashMapWithExpectedSize(srcs.length); final int moveFilesThreadCount = HiveConf.getIntVar(conf, ConfVars.HIVE_MOVE_FILES_THREAD_COUNT); final ExecutorService pool = moveFilesThreadCount > 0
@Override <K, V> Map<K, Collection<V>> createMap() { return newLinkedHashMapWithExpectedSize(expectedKeys); } };
/** Returns an empty mutable map whose keys will respect this {@link ElementOrder}. */ <K extends T, V> Map<K, V> createMap(int expectedSize) { switch (type) { case UNORDERED: return Maps.newHashMapWithExpectedSize(expectedSize); case INSERTION: return Maps.newLinkedHashMapWithExpectedSize(expectedSize); case SORTED: return Maps.newTreeMap(comparator()); default: throw new AssertionError(); } }
public NameBasedDefinitionProvider(AbstractCompiler compiler, boolean allowComplexFunctionDefs) { this.compiler = compiler; this.allowComplexFunctionDefs = allowComplexFunctionDefs; int numInputs = compiler.getNumberOfInputs(); // Estimates below were generated by experimentation with large Google projects. this.definitionsByName = LinkedHashMultimap.create(numInputs * 15, 1); int estimatedDefinitionSites = numInputs * 22; this.definitionSitesByDefinitionSiteNode = Maps.newLinkedHashMapWithExpectedSize(estimatedDefinitionSites); this.definitionSitesByScopeNode = HashMultimap.create(estimatedDefinitionSites, 1); this.definitionNodes = Sets.newHashSetWithExpectedSize(estimatedDefinitionSites); }
private Map<Object, Object> mapToMap(Map<?, ?> map, Descriptors.FieldDescriptor keyFd, Descriptors.FieldDescriptor valFd) { Map<Object, Object> newMap = Maps.newLinkedHashMapWithExpectedSize(map.size()); for (Map.Entry entry : map.entrySet()) { Object key = basicTypeFieldResolver.toSqlValue(keyFd, entry.getKey()); Object value = basicTypeFieldResolver.toSqlValue(valFd, entry.getValue()); newMap.put(key, value); } return newMap; }
private Map<Object, Object> collectionToMap(Collection<? extends MapEntry> valueCollection, Descriptors.FieldDescriptor keyFd, Descriptors.FieldDescriptor valFd) { Map<Object, Object> map = Maps.newLinkedHashMapWithExpectedSize(valueCollection.size()); for (MapEntry entry : valueCollection) { Object key = basicTypeFieldResolver.toSqlValue(keyFd, entry.getKey()); Object value = basicTypeFieldResolver.toSqlValue(valFd, entry.getValue()); map.put(key, value); } return map; }