@Benchmark public ObjectObjectMap<String, String> hppc() { int localSize = this.size; float localLoadFactor = this.loadFactor; String[] localElements = this.elements; int defaultInitialCapacity = Containers.DEFAULT_EXPECTED_ELEMENTS; ObjectObjectMap<String, String> hppc = this.isPresized ? new ObjectObjectHashMap<>(localSize, localLoadFactor) : new ObjectObjectHashMap<>(defaultInitialCapacity, localLoadFactor); for (int i = 0; i < localSize; i++) { hppc.put(localElements[i], "dummy"); } return hppc; }
@Setup public void setUp() { Random random = new Random(123456789012345L); this.elements = new String[this.size]; this.hppcMap = new ObjectObjectHashMap<>(this.size); for (int i = 0; i < this.size; i++) { String element = RandomStringUtils.random(RANDOM_COUNT, 0, 0, false, true, null, random); this.elements[i] = element; this.hppcMap.put(element, "dummy"); } }
transitions = new ObjectObjectHashMap<>(); transitionList = new ObjectArrayList<>();
/** * Returns a new map with the given number of expected elements. * * @param expectedElements * The expected number of elements guaranteed not to cause buffer * expansion (inclusive). */ public static <K, V> ObjectObjectHashMap<K, V> newMap(int expectedElements) { return new ObjectObjectHashMap<>(expectedElements); }
public Builder(int size) { this.map = new ObjectObjectHashMap<>(size); }
/** * Wraps the given map and prevent adding of <code>null</code> keys. * * @param expectedElements * The expected number of elements guaranteed not to cause buffer * expansion (inclusive). */ public static <K, V> ObjectObjectHashMap<K, V> ensureNoNullKeys(int expectedElements) { return new ObjectObjectHashMap<K, V>(expectedElements) { @Override public V put(K key, V value) { if (key == null) { throw new IllegalArgumentException("Map key must not be null"); } return super.put(key, value); } }; }
/** * Creates a hash map from two index-aligned arrays of key-value pairs. */ public static <KType, VType> ObjectObjectHashMap<KType, VType> from(KType[] keys, VType[] values) { if (keys.length != values.length) { throw new IllegalArgumentException("Arrays of keys and values must have an identical length."); } ObjectObjectHashMap<KType, VType> map = new ObjectObjectHashMap<>(keys.length); for (int i = 0; i < keys.length; i++) { map.put(keys[i], values[i]); } return map; }
/** Add fields so that they can later be fetched using {@link #getByKey(Object)}. */ public void addWithKey(Object key, IndexableField field) { if (keyedFields == null) { keyedFields = new ObjectObjectHashMap<>(); } else if (keyedFields.containsKey(key)) { throw new IllegalStateException("Only one field can be stored per key"); } keyedFields.put(key, field); add(field); }
/** * Returns a new map with the given number of expected elements. * * @param expectedElements * The expected number of elements guaranteed not to cause buffer * expansion (inclusive). */ public static <K, V> ObjectObjectHashMap<K, V> newMap(int expectedElements) { return new ObjectObjectHashMap<>(expectedElements); }
/** * Returns a new map with the given number of expected elements. * * @param expectedElements * The expected number of elements guaranteed not to cause buffer * expansion (inclusive). */ public static <K, V> ObjectObjectHashMap<K, V> newMap(int expectedElements) { return new ObjectObjectHashMap<>(expectedElements); }
/** * Returns a new map with the given number of expected elements. * * @param expectedElements * The expected number of elements guaranteed not to cause buffer * expansion (inclusive). */ public static <K, V> ObjectObjectHashMap<K, V> newMap(int expectedElements) { return new ObjectObjectHashMap<>(expectedElements); }
@SuppressWarnings("unchecked") @Override public final synchronized <V> V putInContext(Object key, Object value) { if (context == null) { context = new ObjectObjectHashMap<>(2); } return (V) context.put(key, value); }
public TopicStats() { remotePublishersStats = new ObjectObjectHashMap<String, PublisherStats>(); reset(); }
@Override public void setup(final int[] keys, final float fillFactor, final int oneFailureOutOf ) { super.setup( keys, fillFactor, oneFailureOutOf ); m_map = new ObjectObjectHashMap<>( keys.length, fillFactor ); for (Integer key : m_keys) m_map.put(new Integer( key % oneFailureOutOf == 0 ? key + 1 : key ), key); }
/** Add fields so that they can later be fetched using {@link #getByKey(Object)}. */ public void addWithKey(Object key, IndexableField field) { if (keyedFields == null) { keyedFields = new ObjectObjectHashMap<>(); } else if (keyedFields.containsKey(key)) { throw new IllegalStateException("Only one field can be stored per key"); } keyedFields.put(key, field); add(field); }
/** Add fields so that they can later be fetched using {@link #getByKey(Object)}. */ public void addWithKey(Object key, IndexableField field) { if (keyedFields == null) { keyedFields = new ObjectObjectHashMap<>(); } else if (keyedFields.containsKey(key)) { throw new IllegalStateException("Only one field can be stored per key"); } keyedFields.put(key, field); add(field); }
/** Add fields so that they can later be fetched using {@link #getByKey(Object)}. */ public void addWithKey(Object key, IndexableField field) { if (keyedFields == null) { keyedFields = new ObjectObjectHashMap<>(); } else if (keyedFields.containsKey(key)) { throw new IllegalStateException("Only one field can be stored per key"); } keyedFields.put(key, field); add(field); }
/** Add fields so that they can later be fetched using {@link #getByKey(Object)}. */ public void addWithKey(Object key, IndexableField field) { if (keyedFields == null) { keyedFields = new ObjectObjectHashMap<>(); } else if (keyedFields.containsKey(key)) { throw new IllegalStateException("Only one field can be stored per key"); } keyedFields.put(key, field); add(field); }
public ClusterStatsIndices(List<ClusterStatsNodeResponse> nodeResponses) { ObjectObjectHashMap<String, ShardStats> countsPerIndex = new ObjectObjectHashMap<>();
@Override public int test() { final ObjectObjectMap<Integer, Integer> m_map = new ObjectObjectHashMap<>( m_keys.length, m_fillFactor ); for ( int i = 0; i < m_keys.length; ++i ) m_map.put( m_keys[ i ], m_keys[ i ] ); for ( int i = 0; i < m_keys2.length; ++i ) m_map.put( m_keys2[ i ], m_keys2[ i ] ); return m_map.size(); } }