org.apache.commons.lang3.EnumUtils Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.lang3;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.EnumSet;
/**
* Utility library to provide helper methods for Java enums.
*
* #ThreadSafe#
*
* @since 3.0
* @version $Id: EnumUtils.java 1199894 2011-11-09 17:53:59Z ggregory $
*/
public class EnumUtils {
/**
* This constructor is public to permit tools that require a JavaBean
* instance to operate.
*/
public EnumUtils() {
}
/**
* Gets the {@code Map} of enums by name.
*
* This method is useful when you need a map of enums by name.
*
* @param the type of the enumeration
* @param enumClass the class of the enum to query, not null
* @return the modifiable map of enum names to enums, never null
*/
public static > Map getEnumMap(Class enumClass) {
Map map = new LinkedHashMap();
for (E e: enumClass.getEnumConstants()) {
map.put(e.name(), e);
}
return map;
}
/**
* Gets the {@code List} of enums.
*
* This method is useful when you need a list of enums rather than an array.
*
* @param the type of the enumeration
* @param enumClass the class of the enum to query, not null
* @return the modifiable list of enums, never null
*/
public static > List getEnumList(Class enumClass) {
return new ArrayList(Arrays.asList(enumClass.getEnumConstants()));
}
/**
* Checks if the specified name is a valid enum for the class.
*
* This method differs from {@link Enum#valueOf} in that checks if the name is
* a valid enum without needing to catch the exception.
*
* @param the type of the enumeration
* @param enumClass the class of the enum to query, not null
* @param enumName the enum name, null returns false
* @return true if the enum name is valid, otherwise false
*/
public static > boolean isValidEnum(Class enumClass, String enumName) {
if (enumName == null) {
return false;
}
try {
Enum.valueOf(enumClass, enumName);
return true;
} catch (IllegalArgumentException ex) {
return false;
}
}
/**
* Gets the enum for the class, returning {@code null} if not found.
*
* This method differs from {@link Enum#valueOf} in that it does not throw an exception
* for an invalid enum name.
*
* @param the type of the enumeration
* @param enumClass the class of the enum to query, not null
* @param enumName the enum name, null returns null
* @return the enum, null if not found
*/
public static > E getEnum(Class enumClass, String enumName) {
if (enumName == null) {
return null;
}
try {
return Enum.valueOf(enumClass, enumName);
} catch (IllegalArgumentException ex) {
return null;
}
}
/**
* Creates a long bit vector representation of the given subset of an Enum.
*
* This generates a value that is usable by {@link EnumUtils#processBitVector}.
*
* Do not use this method if you have more than 64 values in your Enum, as this
* would create a value greater than a long can hold.
*
* @param enumClass the class of the enum we are working with, not {@code null}
* @param values the values we want to convert, not {@code null}
* @param the type of the enumeration
* @return a long whose binary value represents the given set of enum values.
* @throws NullPointerException if {@code enumClass} or {@code values} is {@code null}
* @throws IllegalArgumentException if {@code enumClass} is not an enum class or has more than 64 values
* @since 3.0.1
*/
public static > long generateBitVector(Class enumClass, Iterable values) {
checkBitVectorable(enumClass);
Validate.notNull(values);
long total = 0;
for (E constant : values) {
total |= 1 << constant.ordinal();
}
return total;
}
/**
* Creates a long bit vector representation of the given array of Enum values.
*
* This generates a value that is usable by {@link EnumUtils#processBitVector}.
*
* Do not use this method if you have more than 64 values in your Enum, as this
* would create a value greater than a long can hold.
*
* @param enumClass the class of the enum we are working with, not {@code null}
* @param values the values we want to convert, not {@code null}
* @param the type of the enumeration
* @return a long whose binary value represents the given set of enum values.
* @throws NullPointerException if {@code enumClass} or {@code values} is {@code null}
* @throws IllegalArgumentException if {@code enumClass} is not an enum class or has more than 64 values
* @since 3.0.1
*/
public static > long generateBitVector(Class enumClass, E... values) {
Validate.noNullElements(values);
return generateBitVector(enumClass, Arrays. asList(values));
}
/**
* Convert a long value created by {@link EnumUtils#generateBitVector} into the set of
* enum values that it represents.
*
* If you store this value, beware any changes to the enum that would affect ordinal values.
* @param enumClass the class of the enum we are working with, not {@code null}
* @param value the long value representation of a set of enum values
* @param the type of the enumeration
* @return a set of enum values
* @throws NullPointerException if {@code enumClass} is {@code null}
* @throws IllegalArgumentException if {@code enumClass} is not an enum class or has more than 64 values
* @since 3.0.1
*/
public static > EnumSet processBitVector(Class enumClass, long value) {
final E[] constants = checkBitVectorable(enumClass).getEnumConstants();
final EnumSet results = EnumSet.noneOf(enumClass);
for (E constant : constants) {
if ((value & 1 << constant.ordinal()) != 0) {
results.add(constant);
}
}
return results;
}
/**
* Validate that {@code enumClass} is compatible with representation in a {@code long}.
* @param the type of the enumeration
* @param enumClass to check
* @return {@code enumClass}
* @throws NullPointerException if {@code enumClass} is {@code null}
* @throws IllegalArgumentException if {@code enumClass} is not an enum class or has more than 64 values
* @since 3.0.1
*/
private static > Class checkBitVectorable(Class enumClass) {
Validate.notNull(enumClass, "EnumClass must be defined.");
final E[] constants = enumClass.getEnumConstants();
Validate.isTrue(constants != null, "%s does not seem to be an Enum type", enumClass);
Validate.isTrue(constants.length <= Long.SIZE, "Cannot store %s %s values in %s bits", constants.length,
enumClass.getSimpleName(), Long.SIZE);
return enumClass;
}
}