/*
* Copyright (C) 2012 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.collect;
import static com.google.common.base.Preconditions.checkState;
import com.google.common.base.Equivalence;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentSkipListMap;
/**
* Helper classes for various benchmarks.
*
* @author Christopher Swenson
*/
final class BenchmarkHelpers {
/** So far, this is the best way to test various implementations of {@link Set} subclasses. */
public interface CollectionsImplEnum {
<E extends Comparable<E>> Collection<E> create(Collection<E> contents);
String name();
}
public interface MapsImplEnum {
<K extends Comparable<K>, V> Map<K, V> create(Map<K, V> contents);
String name();
}
public interface InternerImplEnum {
<E> Interner<E> create(Collection<E> contents);
String name();
}
public enum SetImpl implements CollectionsImplEnum {
HashSetImpl {
@Override
public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
return new HashSet<E>(contents);
}
},
LinkedHashSetImpl {
@Override
public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
return new LinkedHashSet<E>(contents);
}
},
TreeSetImpl {
@Override
public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
return new TreeSet<E>(contents);
}
},
UnmodifiableSetImpl {
@Override
public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
return Collections.unmodifiableSet(new HashSet<E>(contents));
}
},
SynchronizedSetImpl {
@Override
public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
return Collections.synchronizedSet(new HashSet<E>(contents));
}
},
ImmutableSetImpl {
@Override
public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
return ImmutableSet.copyOf(contents);
}
},
ImmutableSortedSetImpl {
@Override
public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
return ImmutableSortedSet.copyOf(contents);
}
},
ContiguousSetImpl {
@Override
public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
return ContiguousSet.copyOf(contents);
}
},
;
}
public enum ListMultimapImpl {
ArrayListMultimapImpl {
@Override
<K, V> ListMultimap<K, V> create(Multimap<K, V> contents) {
return ArrayListMultimap.create(contents);
}
},
LinkedListMultimapImpl {
@Override
<K, V> ListMultimap<K, V> create(Multimap<K, V> contents) {
return LinkedListMultimap.create(contents);
}
},
ImmutableListMultimapImpl {
@Override
<K, V> ListMultimap<K, V> create(Multimap<K, V> contents) {
return ImmutableListMultimap.copyOf(contents);
}
};
abstract <K, V> ListMultimap<K, V> create(Multimap<K, V> contents);
}
public enum RangeSetImpl {
TreeRangeSetImpl {
@Override
<K extends Comparable<K>> RangeSet<K> create(RangeSet<K> contents) {
return TreeRangeSet.create(contents);
}
},
ImmutableRangeSetImpl {
@Override
<K extends Comparable<K>> RangeSet<K> create(RangeSet<K> contents) {
return ImmutableRangeSet.copyOf(contents);
}
};
abstract <K extends Comparable<K>> RangeSet<K> create(RangeSet<K> contents);
}
public enum SetMultimapImpl {
HashMultimapImpl {
@Override
<K extends Comparable<K>, V extends Comparable<V>> SetMultimap<K, V> create(
Multimap<K, V> contents) {
return HashMultimap.create(contents);
}
},
LinkedHashMultimapImpl {
@Override
<K extends Comparable<K>, V extends Comparable<V>> SetMultimap<K, V> create(
Multimap<K, V> contents) {
return LinkedHashMultimap.create(contents);
}
},
TreeMultimapImpl {
@Override
<K extends Comparable<K>, V extends Comparable<V>> SetMultimap<K, V> create(
Multimap<K, V> contents) {
return TreeMultimap.create(contents);
}
},
ImmutableSetMultimapImpl {
@Override
<K extends Comparable<K>, V extends Comparable<V>> SetMultimap<K, V> create(
Multimap<K, V> contents) {
return ImmutableSetMultimap.copyOf(contents);
}
};
abstract <K extends Comparable<K>, V extends Comparable<V>> SetMultimap<K, V> create(
Multimap<K, V> contents);
}
public enum MapImpl implements MapsImplEnum {
HashMapImpl {
@Override
public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
return Maps.newHashMap(map);
}
},
LinkedHashMapImpl {
@Override
public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
return Maps.newLinkedHashMap(map);
}
},
ConcurrentHashMapImpl {
@Override
public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
return new ConcurrentHashMap<K, V>(map);
}
},
ImmutableMapImpl {
@Override
public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
return ImmutableMap.copyOf(map);
}
},
MapMakerStrongKeysStrongValues {
@Override
public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
// We use a "custom" equivalence to force MapMaker to make a MapMakerInternalMap.
ConcurrentMap<K, V> newMap = new MapMaker().keyEquivalence(Equivalence.equals()).makeMap();
checkState(newMap instanceof MapMakerInternalMap);
newMap.putAll(map);
return newMap;
}
},
MapMakerStrongKeysWeakValues {
@Override
public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
ConcurrentMap<K, V> newMap = new MapMaker().weakValues().makeMap();
checkState(newMap instanceof MapMakerInternalMap);
newMap.putAll(map);
return newMap;
}
},
MapMakerWeakKeysStrongValues {
@Override
public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
ConcurrentMap<K, V> newMap = new MapMaker().weakKeys().makeMap();
checkState(newMap instanceof MapMakerInternalMap);
newMap.putAll(map);
return newMap;
}
},
MapMakerWeakKeysWeakValues {
@Override
public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
ConcurrentMap<K, V> newMap = new MapMaker().weakKeys().weakValues().makeMap();
checkState(newMap instanceof MapMakerInternalMap);
newMap.putAll(map);
return newMap;
}
};
}
enum SortedMapImpl implements MapsImplEnum {
TreeMapImpl {
@Override
public <K extends Comparable<K>, V> SortedMap<K, V> create(Map<K, V> map) {
SortedMap<K, V> result = Maps.newTreeMap();
result.putAll(map);
return result;
}
},
ConcurrentSkipListImpl {
@Override
public <K extends Comparable<K>, V> SortedMap<K, V> create(Map<K, V> map) {
return new ConcurrentSkipListMap<K, V>(map);
}
},
ImmutableSortedMapImpl {
@Override
public <K extends Comparable<K>, V> SortedMap<K, V> create(Map<K, V> map) {
return ImmutableSortedMap.copyOf(map);
}
};
}
enum BiMapImpl implements MapsImplEnum {
HashBiMapImpl {
@Override
public <K extends Comparable<K>, V> BiMap<K, V> create(Map<K, V> map) {
return HashBiMap.create(map);
}
},
ImmutableBiMapImpl {
@Override
public <K extends Comparable<K>, V> BiMap<K, V> create(Map<K, V> map) {
return ImmutableBiMap.copyOf(map);
}
};
@Override
public abstract <K extends Comparable<K>, V> BiMap<K, V> create(Map<K, V> map);
}
enum MultisetImpl implements CollectionsImplEnum {
HashMultisetImpl {
@Override
public <E extends Comparable<E>> Multiset<E> create(Collection<E> contents) {
return HashMultiset.create(contents);
}
},
LinkedHashMultisetImpl {
@Override
public <E extends Comparable<E>> Multiset<E> create(Collection<E> contents) {
return LinkedHashMultiset.create(contents);
}
},
ConcurrentHashMultisetImpl {
@Override
public <E extends Comparable<E>> Multiset<E> create(Collection<E> contents) {
return ConcurrentHashMultiset.create(contents);
}
},
ImmutableMultisetImpl {
@Override
public <E extends Comparable<E>> Multiset<E> create(Collection<E> contents) {
return ImmutableMultiset.copyOf(contents);
}
};
}
enum SortedMultisetImpl implements CollectionsImplEnum {
TreeMultisetImpl {
@Override
public <E extends Comparable<E>> SortedMultiset<E> create(Collection<E> contents) {
return TreeMultiset.create(contents);
}
},
ImmutableSortedMultisetImpl {
@Override
public <E extends Comparable<E>> SortedMultiset<E> create(Collection<E> contents) {
return ImmutableSortedMultiset.copyOf(contents);
}
};
}
enum QueueImpl implements CollectionsImplEnum {
MinMaxPriorityQueueImpl {
@Override
public <E extends Comparable<E>> Queue<E> create(Collection<E> contents) {
return MinMaxPriorityQueue.create(contents);
}
};
}
enum TableImpl {
HashBasedTableImpl {
@Override
<R extends Comparable<R>, C extends Comparable<C>, V> Table<R, C, V> create(
Table<R, C, V> contents) {
return HashBasedTable.create(contents);
}
},
TreeBasedTableImpl {
@Override
<R extends Comparable<R>, C extends Comparable<C>, V> Table<R, C, V> create(
Table<R, C, V> contents) {
Table<R, C, V> table = TreeBasedTable.create();
table.putAll(contents);
return table;
}
},
ArrayTableImpl {
@Override
<R extends Comparable<R>, C extends Comparable<C>, V> Table<R, C, V> create(
Table<R, C, V> contents) {
if (contents.isEmpty()) {
return ImmutableTable.of();
} else {
return ArrayTable.create(contents);
}
}
},
ImmutableTableImpl {
@Override
<R extends Comparable<R>, C extends Comparable<C>, V> Table<R, C, V> create(
Table<R, C, V> contents) {
return ImmutableTable.copyOf(contents);
}
};
abstract <R extends Comparable<R>, C extends Comparable<C>, V>
Table<R, C, V> create(Table<R, C, V> contents);
}
public enum InternerImpl implements InternerImplEnum {
WeakInternerImpl {
@Override
public <E> Interner<E> create(Collection<E> contents) {
Interner<E> interner = Interners.newWeakInterner();
for (E e : contents) {
interner.intern(e);
}
return interner;
}
},
StrongInternerImpl {
@Override
public <E> Interner<E> create(Collection<E> contents) {
Interner<E> interner = Interners.newStrongInterner();
for (E e : contents) {
interner.intern(e);
}
return interner;
}
};
}
public enum Value {
INSTANCE;
}
public enum ListSizeDistribution {
UNIFORM_0_TO_2(0, 2), UNIFORM_0_TO_9(0, 9), ALWAYS_0(0, 0), ALWAYS_10(10, 10);
final int min;
final int max;
private ListSizeDistribution(int min, int max) {
this.min = min;
this.max = max;
}
public int chooseSize(Random random) {
return random.nextInt(max - min + 1) + min;
}
}
}