private void replaceRangeWithSameLowerBound(Range<C> range) { if (range.isEmpty()) { rangesByLowerBound.remove(range.lowerBound); } else { rangesByLowerBound.put(range.lowerBound, range); } }
@Override public V put(K key, V value) { return delegate.put(checkValid(key), value); }
private void putRangeMapEntry(Cut<K> lowerBound, Cut<K> upperBound, V value) { entriesByLowerBound.put(lowerBound, new RangeMapEntry<K, V>(lowerBound, upperBound, value)); }
@Override public void put(Range<K> range, V value) { // don't short-circuit if the range is empty - it may be between two ranges we can coalesce. if (!range.isEmpty()) { checkNotNull(value); remove(range); entriesByLowerBound.put(range.lowerBound, new RangeMapEntry<K, V>(range, value)); } }
@Override protected SortedMap<String, String> create(Entry<String, String>[] entries) { NavigableMap<String, String> map = new SafeTreeMap<>(NullsBeforeTwo.INSTANCE); for (Entry<String, String> entry : entries) { map.put(entry.getKey(), entry.getValue()); } return map; }
@Override protected SortedMap<String, String> create(Entry<String, String>[] entries) { NavigableMap<String, String> map = new SafeTreeMap<>(Ordering.natural()); for (Entry<String, String> entry : entries) { map.put(entry.getKey(), entry.getValue()); } return map; } })
private void testRangesByLowerBounds( TreeRangeSet<Integer> rangeSet, Iterable<Range<Integer>> expectedRanges) { NavigableMap<Cut<Integer>, Range<Integer>> expectedRangesByLowerBound = Maps.newTreeMap(); for (Range<Integer> range : expectedRanges) { expectedRangesByLowerBound.put(range.lowerBound, range); } NavigableMap<Cut<Integer>, Range<Integer>> rangesByLowerBound = rangeSet.rangesByLowerBound; testNavigationAgainstExpected(expectedRangesByLowerBound, rangesByLowerBound, CUTS_TO_TEST); }
@Override protected NavigableMap<String, String> create(Entry<String, String>[] entries) { NavigableMap<String, String> map = new SafeTreeMap<>(); for (Entry<String, String> entry : entries) { map.put(entry.getKey(), encode(entry.getValue())); } return Maps.transformValues(map, DECODE_FUNCTION); } })
@Override protected SortedMap<String, String> create(Entry<String, String>[] entries) { NavigableMap<String, String> map = new SafeTreeMap<>(); for (Entry<String, String> entry : entries) { map.put(entry.getKey(), entry.getValue()); } return new StandardImplForwardingNavigableMap<>(map); } })
@Override protected NavigableMap<String, String> create(Entry<String, String>[] entries) { NavigableMap<String, String> map = new SafeTreeMap<>(); for (Entry<String, String> entry : entries) { map.put(entry.getKey(), encode(entry.getValue())); } return Maps.transformEntries(map, DECODE_ENTRY_TRANSFORMER); } })
public void testFirstKey() { NavigableMap<String, Integer> map = create(); map.put("a", 1); map.firstKey(); }
@Override protected SortedMap<String, String> create(Entry<String, String>[] entries) { NavigableMap<String, String> innermost = new SafeTreeMap<>(); for (Entry<String, String> entry : entries) { innermost.put(entry.getKey(), entry.getValue()); } TestMap<String, String> inner = new TestMap<>(innermost, mutex); NavigableMap<String, String> outer = Synchronized.navigableMap(inner, mutex); return outer; } })
public void testLastKey() { NavigableMap<String, Integer> map = create(); map.put("a", 1); map.lastKey(); }
public void testStandardLastEntry() { NavigableMap<String, Integer> forwarding = new StandardLastEntryForwardingNavigableMap<>(new SafeTreeMap<String, Integer>()); assertNull(forwarding.lastEntry()); forwarding.put("b", 2); assertEquals(immutableEntry("b", 2), forwarding.lastEntry()); forwarding.put("c", 3); assertEquals(immutableEntry("c", 3), forwarding.lastEntry()); forwarding.put("a", 1); assertEquals(immutableEntry("c", 3), forwarding.lastEntry()); forwarding.remove("c"); assertEquals(immutableEntry("b", 2), forwarding.lastEntry()); }
public void testRangesByUpperBound() { for (Range<Integer> range1 : QUERY_RANGES) { for (Range<Integer> range2 : QUERY_RANGES) { TreeRangeSet<Integer> rangeSet = TreeRangeSet.create(); rangeSet.add(range1); rangeSet.add(range2); NavigableMap<Cut<Integer>, Range<Integer>> expectedRangesByUpperBound = Maps.newTreeMap(); for (Range<Integer> range : rangeSet.asRanges()) { expectedRangesByUpperBound.put(range.upperBound, range); } testNavigationAgainstExpected( expectedRangesByUpperBound, new TreeRangeSet.RangesByUpperBound<Integer>(rangeSet.rangesByLowerBound), CUTS_TO_TEST); } } }