335 lines
11 KiB
Java
335 lines
11 KiB
Java
|
/*
|
||
|
|
* 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;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Utility library to provide helper methods for Java enums.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* #ThreadSafe#
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @since 3.0
|
||
|
|
*/
|
||
|
|
public class EnumUtils {
|
||
|
|
|
||
|
|
private static final String NULL_ELEMENTS_NOT_PERMITTED = "null elements not permitted";
|
||
|
|
private static final String CANNOT_STORE_S_S_VALUES_IN_S_BITS = "Cannot store %s %s values in %s bits";
|
||
|
|
private static final String S_DOES_NOT_SEEM_TO_BE_AN_ENUM_TYPE = "%s does not seem to be an Enum type";
|
||
|
|
private static final String ENUM_CLASS_MUST_BE_DEFINED = "EnumClass must be defined.";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Validate {@code enumClass}.
|
||
|
|
*
|
||
|
|
* @param <E> 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
|
||
|
|
* @since 3.2
|
||
|
|
*/
|
||
|
|
private static <E extends Enum<E>> Class<E> asEnum(final Class<E> enumClass) {
|
||
|
|
Validate.notNull(enumClass, ENUM_CLASS_MUST_BE_DEFINED);
|
||
|
|
Validate.isTrue(enumClass.isEnum(), S_DOES_NOT_SEEM_TO_BE_AN_ENUM_TYPE, enumClass);
|
||
|
|
return enumClass;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Validate that {@code enumClass} is compatible with representation in a
|
||
|
|
* {@code long}.
|
||
|
|
*
|
||
|
|
* @param <E> 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 <E extends Enum<E>> Class<E> checkBitVectorable(final Class<E> enumClass) {
|
||
|
|
final E[] constants = asEnum(enumClass).getEnumConstants();
|
||
|
|
Validate.isTrue(constants.length <= Long.SIZE, CANNOT_STORE_S_S_VALUES_IN_S_BITS,
|
||
|
|
Integer.valueOf(constants.length), enumClass.getSimpleName(), Integer.valueOf(Long.SIZE));
|
||
|
|
|
||
|
|
return enumClass;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Creates a long bit vector representation of the given array of Enum values.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This generates a value that is usable by {@link EnumUtils#processBitVector}.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* 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.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @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 <E> the type of the enumeration
|
||
|
|
* @return a long whose value provides a binary representation of 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
|
||
|
|
* @see #generateBitVectors(Class, Iterable)
|
||
|
|
*/
|
||
|
|
@SafeVarargs
|
||
|
|
public static <E extends Enum<E>> long generateBitVector(final Class<E> enumClass, final E... values) {
|
||
|
|
Validate.noNullElements(values);
|
||
|
|
return generateBitVector(enumClass, Arrays.asList(values));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Creates a long bit vector representation of the given subset of an Enum.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This generates a value that is usable by {@link EnumUtils#processBitVector}.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* 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.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @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}, neither
|
||
|
|
* containing {@code null}
|
||
|
|
* @param <E> the type of the enumeration
|
||
|
|
* @return a long whose value provides a binary representation of 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, or if any
|
||
|
|
* {@code values} {@code null}
|
||
|
|
* @since 3.0.1
|
||
|
|
* @see #generateBitVectors(Class, Iterable)
|
||
|
|
*/
|
||
|
|
public static <E extends Enum<E>> long generateBitVector(final Class<E> enumClass,
|
||
|
|
final Iterable<? extends E> values) {
|
||
|
|
checkBitVectorable(enumClass);
|
||
|
|
Validate.notNull(values);
|
||
|
|
long total = 0;
|
||
|
|
for (final E constant : values) {
|
||
|
|
Validate.notNull(constant, NULL_ELEMENTS_NOT_PERMITTED);
|
||
|
|
total |= 1L << constant.ordinal();
|
||
|
|
}
|
||
|
|
return total;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Gets the enum for the class, returning {@code null} if not found.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This method differs from {@link Enum#valueOf} in that it does not throw an
|
||
|
|
* exception for an invalid enum name.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @param <E> 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 extends Enum<E>> E getEnum(final Class<E> enumClass, final String enumName) {
|
||
|
|
return getEnum(enumClass, enumName, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Gets the enum for the class, returning {@code defaultEnum} if not found.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This method differs from {@link Enum#valueOf} in that it does not throw an
|
||
|
|
* exception for an invalid enum name.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @param <E> the type of the enumeration
|
||
|
|
* @param enumClass the class of the enum to query, not null
|
||
|
|
* @param enumName the enum name, null returns default enum
|
||
|
|
* @param defaultEnum the default enum
|
||
|
|
* @return the enum, default enum if not found
|
||
|
|
* @since 3.10
|
||
|
|
*/
|
||
|
|
public static <E extends Enum<E>> E getEnum(final Class<E> enumClass, final String enumName, final E defaultEnum) {
|
||
|
|
if (enumName == null) {
|
||
|
|
return defaultEnum;
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
return Enum.valueOf(enumClass, enumName);
|
||
|
|
} catch (final IllegalArgumentException ex) {
|
||
|
|
return defaultEnum;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Gets the enum for the class, returning {@code null} if not found.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This method differs from {@link Enum#valueOf} in that it does not throw an
|
||
|
|
* exception for an invalid enum name and performs case insensitive matching of
|
||
|
|
* the name.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @param <E> 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
|
||
|
|
* @since 3.8
|
||
|
|
*/
|
||
|
|
public static <E extends Enum<E>> E getEnumIgnoreCase(final Class<E> enumClass, final String enumName) {
|
||
|
|
return getEnumIgnoreCase(enumClass, enumName, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Gets the enum for the class, returning {@code defaultEnum} if not found.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This method differs from {@link Enum#valueOf} in that it does not throw an
|
||
|
|
* exception for an invalid enum name and performs case insensitive matching of
|
||
|
|
* the name.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @param <E> the type of the enumeration
|
||
|
|
* @param enumClass the class of the enum to query, not null
|
||
|
|
* @param enumName the enum name, null returns default enum
|
||
|
|
* @param defaultEnum the default enum
|
||
|
|
* @return the enum, default enum if not found
|
||
|
|
* @since 3.10
|
||
|
|
*/
|
||
|
|
public static <E extends Enum<E>> E getEnumIgnoreCase(final Class<E> enumClass, final String enumName,
|
||
|
|
final E defaultEnum) {
|
||
|
|
if (enumName == null || !enumClass.isEnum()) {
|
||
|
|
return defaultEnum;
|
||
|
|
}
|
||
|
|
for (final E each : enumClass.getEnumConstants()) {
|
||
|
|
if (each.name().equalsIgnoreCase(enumName)) {
|
||
|
|
return each;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return defaultEnum;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Gets the {@code List} of enums.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This method is useful when you need a list of enums rather than an array.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @param <E> 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 <E extends Enum<E>> List<E> getEnumList(final Class<E> enumClass) {
|
||
|
|
return new ArrayList<>(Arrays.asList(enumClass.getEnumConstants()));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Gets the {@code Map} of enums by name.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This method is useful when you need a map of enums by name.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @param <E> 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 <E extends Enum<E>> Map<String, E> getEnumMap(final Class<E> enumClass) {
|
||
|
|
final Map<String, E> map = new LinkedHashMap<>();
|
||
|
|
for (final E e : enumClass.getEnumConstants()) {
|
||
|
|
map.put(e.name(), e);
|
||
|
|
}
|
||
|
|
return map;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Checks if the specified name is a valid enum for the class.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This method differs from {@link Enum#valueOf} in that checks if the name is a
|
||
|
|
* valid enum without needing to catch the exception.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @param <E> 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 <E extends Enum<E>> boolean isValidEnum(final Class<E> enumClass, final String enumName) {
|
||
|
|
return getEnum(enumClass, enumName) != null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* <p>
|
||
|
|
* Checks if the specified name is a valid enum for the class.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
* This method differs from {@link Enum#valueOf} in that checks if the name is a
|
||
|
|
* valid enum without needing to catch the exception and performs case
|
||
|
|
* insensitive matching of the name.
|
||
|
|
* </p>
|
||
|
|
*
|
||
|
|
* @param <E> 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
|
||
|
|
* @since 3.8
|
||
|
|
*/
|
||
|
|
public static <E extends Enum<E>> boolean isValidEnumIgnoreCase(final Class<E> enumClass, final String enumName) {
|
||
|
|
return getEnumIgnoreCase(enumClass, enumName) != null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This constructor is public to permit tools that require a JavaBean instance
|
||
|
|
* to operate.
|
||
|
|
*/
|
||
|
|
public EnumUtils() {
|
||
|
|
}
|
||
|
|
}
|