Lines Matching refs:map
65 import java.util.Map;
122 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());
124 assertSame(Strength.STRONG, map.keyStrength);
125 assertSame(Strength.STRONG, map.valueStrength);
126 assertSame(map.keyStrength.defaultEquivalence(), map.keyEquivalence);
127 assertSame(map.valueStrength.defaultEquivalence(), map.valueEquivalence);
129 assertEquals(0, map.expireAfterAccessNanos);
130 assertEquals(0, map.expireAfterWriteNanos);
131 assertEquals(0, map.refreshNanos);
132 assertEquals(CacheBuilder.UNSET_INT, map.maxWeight);
134 assertSame(EntryFactory.STRONG, map.entryFactory);
135 assertSame(CacheBuilder.NullListener.INSTANCE, map.removalListener);
136 assertSame(DISCARDING_QUEUE, map.removalNotificationQueue);
137 assertSame(NULL_TICKER, map.ticker);
139 assertEquals(4, map.concurrencyLevel);
142 assertEquals(4, map.segments.length);
144 assertEquals(16 / map.segments.length, map.segments[0].table.length());
146 assertFalse(map.evictsBySize());
147 assertFalse(map.expires());
148 assertFalse(map.expiresAfterWrite());
149 assertFalse(map.expiresAfterAccess());
150 assertFalse(map.refreshes());
166 LocalCache<Object, Object> map =
168 assertSame(testEquivalence, map.keyEquivalence);
169 assertSame(map.valueStrength.defaultEquivalence(), map.valueEquivalence);
185 LocalCache<Object, Object> map =
187 assertSame(testEquivalence, map.valueEquivalence);
188 assertSame(map.keyStrength.defaultEquivalence(), map.keyEquivalence);
205 LocalCache<Object, Object> map =
207 assertEquals(segmentCount, map.segments.length);
246 LocalCache<Object, Object> map = makeLocalCache(
248 for (int i = 0; i < map.segments.length; i++) {
249 assertEquals(segmentSize, map.segments[i].table.length());
279 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
284 for (int i = 0; i < map.segments.length; i++) {
285 totalCapacity += map.segments[i].maxSegmentWeight;
289 map = makeLocalCache(createCacheBuilder()
295 for (int i = 0; i < map.segments.length; i++) {
296 totalCapacity += map.segments[i].maxSegmentWeight;
308 LocalCache<Object, Object> map =
310 assertSame(testWeigher, map.weigher);
314 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().weakKeys());
315 checkStrength(map, Strength.WEAK, Strength.STRONG);
316 assertSame(EntryFactory.WEAK, map.entryFactory);
320 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().weakValues());
321 checkStrength(map, Strength.STRONG, Strength.WEAK);
322 assertSame(EntryFactory.STRONG, map.entryFactory);
326 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().softValues());
327 checkStrength(map, Strength.STRONG, Strength.SOFT);
328 assertSame(EntryFactory.STRONG, map.entryFactory);
332 LocalCache<Object, Object> map, Strength keyStrength, Strength valueStrength) {
333 assertSame(keyStrength, map.keyStrength);
334 assertSame(valueStrength, map.valueStrength);
335 assertSame(keyStrength.defaultEquivalence(), map.keyEquivalence);
336 assertSame(valueStrength.defaultEquivalence(), map.valueEquivalence);
342 LocalCache<Object, Object> map =
344 assertEquals(unit.toNanos(duration), map.expireAfterWriteNanos);
350 LocalCache<Object, Object> map =
352 assertEquals(unit.toNanos(duration), map.expireAfterAccessNanos);
358 LocalCache<Object, Object> map =
360 assertEquals(unit.toNanos(duration), map.refreshNanos);
365 LocalCache<Object, Object> map =
367 assertSame(testListener, map.removalListener);
377 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().ticker(testTicker));
378 assertSame(testTicker, map.ticker);
404 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());
408 Object value = map.get(key, loader);
410 assertEquals(value, map.get(key, loader));
417 LocalCache<Object, Object> map =
419 Segment<Object, Object> segment = map.segments[0];
424 int hash = map.hash(key);
426 map.get(key, loader);
432 checkEvictionQueues(map, segment, readOrder, writeOrder);
433 checkExpirationTimes(map);
443 map.get(entry.getKey(), loader);
450 checkAndDrainRecencyQueue(map
453 checkEvictionQueues(map, segment, readOrder, writeOrder);
454 checkExpirationTimes(map);
460 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());
465 map.put(key, value);
467 assertEquals(value, map.get(key, loader));
474 LocalCache<Object, Object> map = makeLocalCache(builder);
475 Segment<Object, Object> segment = map.segments[0];
480 int hash = map.hash(key);
490 assertSame(value, map.get(key, loader));
495 assertNotSame(value, map.get(key, loader));
503 LocalCache<Object, Object> map = makeLocalCache(builder);
504 Segment<Object, Object> segment = map.segments[0];
509 int hash = map.hash(key);
519 assertSame(value, map.get(key, loader));
524 assertNotSame(value, map.get(key, loader));
533 LocalCache<Object, Object> map = makeLocalCache(builder);
537 Object one = map.get(key, loader);
540 Object two = map.get(key, loader);
564 final LocalCache<Object, Object> map = makeLocalCache(builder);
565 Segment<Object, Object> segment = map.segments[0];
570 int hash = map.hash(one);
577 map.get(one, loader);
595 map.get(one, loader);
619 map.cleanUp(); // force notifications
621 assertTrue(map.containsKey(one));
622 assertEquals(1, map.size());
623 assertSame(computedObject, map.get(one));
662 final LocalCache<Object, Object> map = makeLocalCache(builder);
672 map.get(one, loader);
686 map.put(one, two);
687 assertSame(two, map.get(one));
696 map.cleanUp(); // force notifications
702 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
704 Segment<Object, Object> segment = map.segments[0];
707 int hash = map.hash(key);
724 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
735 map.put(one, two);
736 map.remove(one);
739 map.put(two, three);
740 map.remove(two, three);
743 map.put(three, four);
744 Iterator<?> i = map.entrySet().iterator();
749 map.put(four, five);
750 i = map.keySet().iterator();
755 map.put(five, six);
756 i = map.values().iterator();
766 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
777 map.put(one, two);
778 map.put(one, three);
781 Map<Object, Object> newMap = ImmutableMap.of(one, four);
782 map.putAll(newMap);
785 map.replace(one, five);
788 map.replace(one, five, six);
794 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
798 Segment<Object, Object> segment = map.segments[0];
805 map.put(one, two);
806 map.put(two, three);
809 int hash = map.hash(one);
811 map.reclaimValue(entry.getValueReference());
820 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
833 map.put(one, two);
835 map.put(two, three);
837 map.put(three, four);
840 map.put(four, five);
848 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
859 map.put(one, two);
860 map.put(two, three);
862 map.put(three, four);
880 LocalCache<Object, Object> map = makeLocalCache(builder);
884 int hashOne = map.hash(keyOne);
885 ReferenceEntry<Object, Object> entryOne = map.newEntry(keyOne, hashOne, null);
886 ValueReference<Object, Object> valueRefOne = map.newValueReference(entryOne, valueOne, 1);
897 int hashTwo = map.hash(keyTwo);
898 ReferenceEntry<Object, Object> entryTwo = map.newEntry(keyTwo, hashTwo, entryOne);
899 ValueReference<Object, Object> valueRefTwo = map.newValueReference(entryTwo, valueTwo, 1);
912 LocalCache<Object, Object> map = makeLocalCache(builder);
916 int hashOne = map.hash(keyOne);
917 ReferenceEntry<Object, Object> entryOne = map.newEntry(keyOne, hashOne, null);
918 entryOne.setValueReference(map.newValueReference(entryOne, valueOne, 1));
922 int hashTwo = map.hash(keyTwo);
923 ReferenceEntry<Object, Object> entryTwo = map.newEntry(keyTwo, hashTwo, entryOne);
924 entryTwo.setValueReference(map.newValueReference(entryTwo, valueTwo, 1));
925 if (map.usesAccessQueue()) {
928 if (map.usesWriteQueue()) {
931 assertConnected(map, entryOne, entryTwo);
933 ReferenceEntry<Object, Object> copyOne = map.copyEntry(entryOne, null);
938 assertConnected(map, copyOne, entryTwo);
940 ReferenceEntry<Object, Object> copyTwo = map.copyEntry(entryTwo, copyOne);
945 assertConnected(map, copyOne, copyTwo);
950 LocalCache<K, V> map, ReferenceEntry<K, V> one, ReferenceEntry<K, V> two) {
951 if (map.usesWriteQueue()) {
954 if (map.usesAccessQueue()) {
961 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
965 Segment<Object, Object> segment = map.segments[0];
969 int hash = map.hash(key);
974 ReferenceEntry<Object, Object> entry = map.newEntry(key, hash, null);
975 ValueReference<Object, Object> valueRef = map.newValueReference(entry, value, 1);
997 ValueReference<Object, Object> nullValueRef = map.newValueReference(nullEntry, nullValue, 1);
1009 ValueReference<Object, Object> dummyValueRef = map.newValueReference(dummy, dummyValue, 1);
1020 dummyValueRef = map.newValueReference(dummy, dummyValue, 1);
1038 LocalCache<Object, Object> map =
1040 Segment<Object, Object> segment = map.segments[0];
1044 int hash = map.hash(key);
1082 LocalCache<Object, Object> map =
1084 Segment<Object, Object> segment = map.segments[0];
1088 int hash = map.hash(key);
1121 LocalCache<Object, Object> map =
1123 Segment<Object, Object> segment = map.segments[0];
1127 int hash = map.hash(key);
1153 LocalCache<Object, Object> map =
1155 Segment<Object, Object> segment = map.segments[0];
1159 int hash = map.hash(key);
1185 LocalCache<Object, Object> map =
1187 Segment<Object, Object> segment = map.segments[0];
1194 int hash = map.hash(key);
1202 LocalCache<Object, Object> map =
1211 map.put(key, value);
1218 assertEquals(originalMap, map);
1224 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
1227 Segment<Object, Object> segment = map.segments[0];
1230 int hash = map.hash(key);
1260 map.clear();
1301 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().concurrencyLevel(1));
1302 Segment<Object, Object> segment = map.segments[0];
1305 int hash = map.hash(key);
1340 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().concurrencyLevel(1));
1341 Segment<Object, Object> segment = map.segments[0];
1344 int hash = map.hash(key);
1386 LocalCache<Object, Object> map =
1388 Segment<Object, Object> segment = map.segments[0];
1397 int hash = map.hash(key);
1399 entry = map.newEntry(key, hash, entry);
1400 ValueReference<Object, Object> valueRef = map.newValueReference(entry, value, 1);
1405 ImmutableMap<Object, Object> originalMap = ImmutableMap.copyOf(map);
1407 assertEquals(originalMap, map);
1414 assertEquals(originalCount, countLiveEntries(map, 0));
1416 assertEquals(originalMap, map);
1422 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
1428 Segment<Object, Object> segment = map.segments[0];
1435 int hashOne = map.hash(keyOne);
1439 int hashTwo = map.hash(keyTwo);
1443 int hashThree = map.hash(keyThree);
1465 assertTrue(map.removalNotificationQueue.isEmpty());
1473 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().concurrencyLevel(1));
1474 Segment<Object, Object> segment = map.segments[0];
1479 int hashOne = map.hash(keyOne);
1483 int hashTwo = map.hash(keyTwo);
1487 int hashThree = map.hash(keyThree);
1517 LocalCache<Object, Object> map =
1519 Segment<Object, Object> segment = map.segments[0];
1529 int hash = map.hash(key);
1542 assertEquals(liveCount, countLiveEntries(map, 0));
1543 ImmutableMap<Object, Object> originalMap = ImmutableMap.copyOf(map);
1545 // can't compare map contents until cleanup occurs
1552 assertEquals(liveCount, countLiveEntries(map, 0));
1556 assertEquals(originalMap, ImmutableMap.copyOf(map));
1560 private static <K, V> int countLiveEntries(LocalCache<K, V> map, long now) {
1562 for (Segment<K, V> segment : map.segments) {
1566 if (map.isLive(e, now)) {
1576 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
1581 Segment<Object, Object> segment = map.segments[0];
1587 int hash = map.hash(key);
1589 segment.recordWrite(entry, 1, map.ticker.read());
1610 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
1616 Segment<Object, Object> segment = map.segments[0];
1622 int hash = map.hash(key);
1624 segment.recordWrite(entry, 1, map.ticker.read());
1645 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
1651 Segment<Object, Object> segment = map.segments[0];
1657 int hash = map.hash(key);
1664 segment.recordWrite(entry, 1, map.ticker.read());
1668 assertNotificationEnqueued(map, key, value, hash);
1669 assertTrue(map.removalNotificationQueue.isEmpty());
1679 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
1685 Segment<Object, Object> segment = map.segments[0];
1691 int hash = map.hash(key);
1700 segment.recordWrite(entry, 1, map.ticker.read());
1707 assertTrue(map.removalNotificationQueue.isEmpty());
1726 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
1732 Segment<Object, Object> segment = map.segments[0];
1737 int hash = map.hash(key);
1750 assertTrue(map.removalNotificationQueue.isEmpty());
1775 LocalCache<K, V> map, K key, V value, int hash) {
1776 RemovalNotification<K, V> notification = map.removalNotificationQueue.poll();
1785 LocalCache<Object, Object> map = makeLocalCache(builder.concurrencyLevel(1));
1786 Segment<Object, Object> segment = map.segments[0];
1794 map.put(keyOne, valueOne);
1798 map.get(keyOne);
1802 map.put(keyTwo, valueTwo);
1810 LocalCache<Object, Object> map = makeLocalCache(builder.concurrencyLevel(1));
1811 Segment<Object, Object> segment = map.segments[0];
1819 map.put(keyOne, valueOne);
1823 map.get(keyOne);
1828 map.get(keyOne);
1835 map.put(new Object(), new Object());
1840 map.get(keyOne);
1844 for (Object key : map.keySet()) {
1845 map.get(key);
1854 LocalCache<Object, Object> map = makeLocalCache(builder.concurrencyLevel(1));
1855 Segment<Object, Object> segment = map.segments[0];
1860 int hash = map.hash(key);
1865 segment.recordWrite(entry, 1, map.ticker.read());
1870 checkEvictionQueues(map, segment, readOrder, writeOrder);
1871 checkExpirationTimes(map);
1880 segment.recordRead(entry, map.ticker.read());
1885 checkAndDrainRecencyQueue(map, segment, reads);
1888 checkEvictionQueues(map, segment, readOrder, writeOrder);
1889 checkExpirationTimes(map);
1895 LocalCache<Object, Object> map = makeLocalCache(builder.concurrencyLevel(1));
1896 Segment<Object, Object> segment = map.segments[0];
1901 int hash = map.hash(key);
1904 map.put(key, value);
1910 checkEvictionQueues(map, segment, readOrder, writeOrder);
1911 checkExpirationTimes(map);
1921 map.get(entry.getKey());
1928 checkAndDrainRecencyQueue(map, segment, reads.subList(undrainedIndex, reads.size()));
1931 checkEvictionQueues(map, segment, readOrder, writeOrder);
1932 checkExpirationTimes(map);
1938 LocalCache<Object, Object> map = makeLocalCache(builder.concurrencyLevel(1));
1939 Segment<Object, Object> segment = map.segments[0];
1943 int hash = map.hash(key);
1948 segment.recordWrite(entry, 1, map.ticker.read());
1952 checkEvictionQueues(map, segment, writeOrder, writeOrder);
1953 checkExpirationTimes(map);
1962 segment.recordWrite(entry, 1, map.ticker.read());
1969 checkEvictionQueues(map, segment, writeOrder, writeOrder);
1970 checkExpirationTimes(map);
1974 static <K, V> void checkAndDrainRecencyQueue(LocalCache<K, V> map,
1976 if (map.evictsBySize() || map.expiresAfterAccess()) {
1982 static <K, V> void checkEvictionQueues(LocalCache<K, V> map,
1985 if (map.evictsBySize() || map.expiresAfterAccess()) {
1988 if (map.expiresAfterWrite()) {
2005 static <K, V> void checkExpirationTimes(LocalCache<K, V> map) {
2006 if (!map.expires()) {
2010 for (Segment<K, V> segment : map.segments) {
2039 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
2043 Segment<Object, Object> segment = map.segments[0];
2047 map.put(key, value);
2048 ReferenceEntry<Object, Object> entry = map.getEntry(key);
2049 assertTrue(map.isLive(entry, ticker.read()));
2052 assertSame(value, map.get(key));
2058 assertSame(value, map.get(key));
2065 assertSame(value, map.get(key));
2070 assertNull(map.get(key));
2072 assertNull(map.get(key));
2078 LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder()
2082 Segment<Object, Object> segment = map.segments[0];
2086 map.put(key, value);
2087 ReferenceEntry<Object, Object> entry = map.getEntry(key);
2088 assertTrue(map.isLive(entry, ticker.read()));
2091 assertSame(value, map.get(key));
2097 assertTrue(map.containsKey(key));
2104 assertTrue(map.containsKey(key));
2111 assertTrue(map.containsKey(key));
2117 assertTrue(map.containsKey(key));
2122 assertFalse(map.containsKey(key));
2123 assertNull(map.get(key));
2125 assertFalse(map.containsKey(key));
2126 assertNull(map.get(key));
2132 LocalCache<Object, Object> map =
2134 Segment<Object, Object> segment = map.segments[0];
2144 int hash = map.hash(key);
2147 entry = map.newEntry(key, hash, first);
2148 ValueReference<Object, Object> valueRef = map.newValueReference(entry, value, 1);
2150 segment.recordWrite(entry, 1, map.ticker.read());
2156 assertEquals(originalCount, map.size());
2157 assertEquals(originalMap, map);
2165 assertEquals(maxSize, map.size());
2166 assertEquals(originalMap, map);
2173 LocalCache<Object, Object> map =
2175 if (map.usesKeyReferences()) {
2176 Segment<Object, Object> segment = map.segments[0];
2179 int hashOne = map.hash(keyOne);
2184 map.put(keyOne, valueOne);
2191 map.put(keyTwo, valueTwo);
2192 assertFalse(map.containsKey(keyOne));
2193 assertFalse(map.containsValue(valueOne));
2194 assertNull(map.get(keyOne));
2195 assertEquals(1, map.size());
2203 LocalCache<Object, Object> map =
2205 if (map.usesValueReferences()) {
2206 Segment<Object, Object> segment = map.segments[0];
2209 int hashOne = map.hash(keyOne);
2214 map.put(keyOne, valueOne);
2222 map.put(keyTwo, valueTwo);
2223 assertFalse(map.containsKey(keyOne));
2224 assertFalse(map.containsValue(valueOne));
2225 assertNull(map.get(keyOne));
2226 assertEquals(1, map.size());
2234 LocalCache<Object, Object> map =
2236 if (map.usesKeyReferences()) {
2237 Segment<Object, Object> segment = map.segments[0];
2240 int hashOne = map.hash(keyOne);
2244 map.put(keyOne, valueOne);
2252 map.get(keyTwo);
2254 assertFalse(map.containsKey(keyOne));
2255 assertFalse(map.containsValue(valueOne));
2256 assertNull(map.get(keyOne));
2257 assertEquals(0, map.size());
2265 LocalCache<Object, Object> map =
2267 if (map.usesValueReferences()) {
2268 Segment<Object, Object> segment = map.segments[0];
2271 int hashOne = map.hash(keyOne);
2275 map.put(keyOne, valueOne);
2284 map.get(keyTwo);
2286 assertFalse(map.containsKey(keyOne));
2287 assertFalse(map.containsValue(valueOne));
2288 assertNull(map.get(keyOne));
2289 assertEquals(0, map.size());
