Java tutorial
// Copyright 2014 The Bazel Authors. All rights reserved. // // 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.devtools.build.lib.collect; import static com.google.common.collect.Sets.newEnumSet; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.devtools.build.lib.collect.nestedset.NestedSet; import com.google.devtools.build.lib.util.Preconditions; import java.util.ArrayList; import java.util.Collection; import java.util.Comparator; import java.util.EnumSet; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; /** * Utilities for collection classes. */ public final class CollectionUtils { private CollectionUtils() { } /** * Given a collection of elements and an equivalence relation, returns a new * unordered collection of the disjoint subsets of those elements which are * equivalent under the specified relation. * * <p>Note: the Comparator needs only to implement the less-strict contract * of EquivalenceRelation (q.v.). (Hopefully this will one day be a * superinterface of Comparator.) * * @param elements the collection of elements to be partitioned. May * contain duplicates. * @param equivalenceRelation an equivalence relation over the elements. * @return a collection of sets of elements that are equivalent under the * specified relation. */ public static <T> Collection<Set<T>> partition(Collection<T> elements, Comparator<T> equivalenceRelation) { // TODO(bazel-team): (2009) O(n*m) where n=|elements| and m=|eqClasses|; i.e., // quadratic. Use Tarjan's algorithm instead. List<Set<T>> eqClasses = new ArrayList<>(); for (T element : elements) { boolean found = false; for (Set<T> eqClass : eqClasses) { if (equivalenceRelation.compare(eqClass.iterator().next(), element) == 0) { eqClass.add(element); found = true; break; } } if (!found) { Set<T> eqClass = new HashSet<>(); eqClass.add(element); eqClasses.add(eqClass); } } return eqClasses; } /** * See partition(Collection, Comparator). */ public static <T> Collection<Set<T>> partition(Collection<T> elements, final EquivalenceRelation<T> equivalenceRelation) { return partition(elements, new Comparator<T>() { @Override public int compare(T o1, T o2) { return equivalenceRelation.compare(o1, o2); } }); } /** * Returns the set of all elements in the given collection that appear more than once. * @param input some collection. * @return the set of repeated elements. May return an empty set, but never null. */ public static <T> Set<T> duplicatedElementsOf(Iterable<T> input) { Set<T> duplicates = new HashSet<>(); Set<T> elementSet = new HashSet<>(); for (T el : input) { if (!elementSet.add(el)) { duplicates.add(el); } } return duplicates; } /** * Returns an immutable list of all non-null parameters in the order in which * they are specified. */ @SuppressWarnings("unchecked") public static <T> ImmutableList<T> asListWithoutNulls(T... elements) { ImmutableList.Builder<T> builder = ImmutableList.builder(); for (T element : elements) { if (element != null) { builder.add(element); } } return builder.build(); } /** * Returns true if the given iterable can be verified to be immutable. * * <p>Note that if this method returns false, that does not mean that the iterable is mutable. */ public static <T> boolean isImmutable(Iterable<T> iterable) { return iterable instanceof ImmutableList<?> || iterable instanceof ImmutableSet<?> || iterable instanceof IterablesChain<?> || iterable instanceof NestedSet<?> || iterable instanceof ImmutableIterable<?>; } /** * Throws a runtime exception if the given iterable can not be verified to be immutable. */ public static <T> void checkImmutable(Iterable<T> iterable) { Preconditions.checkState(isImmutable(iterable), iterable.getClass()); } /** * Given an iterable, returns an immutable iterable with the same contents. */ public static <T> Iterable<T> makeImmutable(Iterable<T> iterable) { if (isImmutable(iterable)) { return iterable; } else { return ImmutableList.copyOf(iterable); } } /** * Converts a set of enum values to a bit field. Requires that the enum contains at most 32 * elements. */ public static <T extends Enum<T>> int toBits(Set<T> values) { int result = 0; for (T value : values) { // <p>Note that when the 32. bit is set, the integer becomes negative (because that is the // sign bit). This does not affect the function of the bitwise operators, so it is fine. Preconditions.checkArgument(value.ordinal() < 32); result |= (1 << value.ordinal()); } return result; } /** * Converts a set of enum values to a bit field. Requires that the enum contains at most 32 * elements. */ @SuppressWarnings("unchecked") public static <T extends Enum<T>> int toBits(T... values) { return toBits(ImmutableSet.copyOf(values)); } /** * Converts a bit field to a set of enum values. Requires that the enum contains at most 32 * elements. */ public static <T extends Enum<T>> EnumSet<T> fromBits(int value, Class<T> clazz) { T[] elements = clazz.getEnumConstants(); Preconditions.checkArgument(elements.length <= 32); ArrayList<T> result = new ArrayList<>(); for (T element : elements) { if ((value & (1 << element.ordinal())) != 0) { result.add(element); } } return newEnumSet(result, clazz); } /** * Returns whether an {@link Iterable} is a superset of another one. */ public static <T> boolean containsAll(Iterable<T> superset, Iterable<T> subset) { return ImmutableSet.copyOf(superset).containsAll(ImmutableList.copyOf(subset)); } /** * Returns an ImmutableMap of ImmutableMaps created from the Map of Maps parameter. */ public static <KEY_1, KEY_2, VALUE> ImmutableMap<KEY_1, ImmutableMap<KEY_2, VALUE>> toImmutable( Map<KEY_1, Map<KEY_2, VALUE>> map) { ImmutableMap.Builder<KEY_1, ImmutableMap<KEY_2, VALUE>> builder = ImmutableMap.builder(); for (Map.Entry<KEY_1, Map<KEY_2, VALUE>> entry : map.entrySet()) { builder.put(entry.getKey(), ImmutableMap.copyOf(entry.getValue())); } return builder.build(); } /** * Returns a copy of the Map of Maps parameter. */ public static <KEY_1, KEY_2, VALUE> Map<KEY_1, Map<KEY_2, VALUE>> copyOf( Map<KEY_1, ? extends Map<KEY_2, VALUE>> map) { Map<KEY_1, Map<KEY_2, VALUE>> result = new HashMap<>(); for (Map.Entry<KEY_1, ? extends Map<KEY_2, VALUE>> entry : map.entrySet()) { result.put(entry.getKey(), new HashMap<>(entry.getValue())); } return result; } }