This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
The following commit(s) were added to refs/heads/master by this push:
new 619a702 Sort methods.
619a702 is described below
commit 619a7024c4a808fbd3cde9d8545959d77a94717b
Author: Gary Gregory <[email protected]>
AuthorDate: Mon Oct 28 14:30:14 2019 -0400
Sort methods.
---
.../java/org/apache/commons/lang3/EnumUtils.java | 316 ++++++++++-----------
1 file changed, 158 insertions(+), 158 deletions(-)
diff --git a/src/main/java/org/apache/commons/lang3/EnumUtils.java
b/src/main/java/org/apache/commons/lang3/EnumUtils.java
index 88b2c3c..75b052a 100644
--- a/src/main/java/org/apache/commons/lang3/EnumUtils.java
+++ b/src/main/java/org/apache/commons/lang3/EnumUtils.java
@@ -39,72 +39,149 @@ public class EnumUtils {
private static final String ENUM_CLASS_MUST_BE_DEFINED = "EnumClass must
be defined.";
/**
- * This constructor is public to permit tools that require a JavaBean
- * instance to operate.
+ * 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
*/
- public EnumUtils() {
+ 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;
}
/**
- * <p>Gets the {@code Map} of enums by name.</p>
+ * 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 method is useful when you need a map of enums by name.</p>
+ * <p>This generates a value that is usable by {@link
EnumUtils#processBitVector}.</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
+ * <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)
*/
- 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;
+ @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>Gets the {@code List} of enums.</p>
+ * <p>Creates a long bit vector representation of the given subset of an
Enum.</p>
*
- * <p>This method is useful when you need a list of enums rather than an
array.</p>
+ * <p>This generates a value that is usable by {@link
EnumUtils#processBitVector}.</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
+ * <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>> List<E> getEnumList(final Class<E>
enumClass) {
- return new ArrayList<>(Arrays.asList(enumClass.getEnumConstants()));
+ 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.isTrue(constant != null, NULL_ELEMENTS_NOT_PERMITTED);
+ total |= 1L << constant.ordinal();
+ }
+ return total;
}
/**
- * <p>Checks if the specified name is a valid enum for the class.</p>
+ * <p>Creates a bit vector representation of the given subset of an Enum
using as many {@code long}s as needed.</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>
+ * <p>This generates a value that is usable by {@link
EnumUtils#processBitVectors}.</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
+ * <p>Use this method if you have more than 64 values in your Enum.</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 values provide a binary representation of the
given set of enum values
+ * with least significant digits rightmost.
+ * @throws NullPointerException if {@code enumClass} or {@code values} is
{@code null}
+ * @throws IllegalArgumentException if {@code enumClass} is not an enum
class, or if any {@code values} {@code null}
+ * @since 3.2
*/
- public static <E extends Enum<E>> boolean isValidEnum(final Class<E>
enumClass, final String enumName) {
- return getEnum(enumClass, enumName) != null;
+ @SafeVarargs
+ public static <E extends Enum<E>> long[] generateBitVectors(final Class<E>
enumClass, final E... values) {
+ asEnum(enumClass);
+ Validate.noNullElements(values);
+ final EnumSet<E> condensed = EnumSet.noneOf(enumClass);
+ Collections.addAll(condensed, values);
+ final long[] result = new long[(enumClass.getEnumConstants().length -
1) / Long.SIZE + 1];
+ for (final E value : condensed) {
+ result[value.ordinal() / Long.SIZE] |= 1L << (value.ordinal() %
Long.SIZE);
+ }
+ ArrayUtils.reverse(result);
+ return result;
}
/**
- * <p>Checks if the specified name is a valid enum for the class.</p>
+ * <p>Creates a bit vector representation of the given subset of an Enum
using as many {@code long}s as needed.</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>
+ * <p>This generates a value that is usable by {@link
EnumUtils#processBitVectors}.</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
+ * <p>Use this method if you have more than 64 values in your Enum.</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 values provide a binary representation of the
given set of enum values
+ * with least significant digits rightmost.
+ * @throws NullPointerException if {@code enumClass} or {@code values} is
{@code null}
+ * @throws IllegalArgumentException if {@code enumClass} is not an enum
class, or if any {@code values} {@code null}
+ * @since 3.2
*/
- public static <E extends Enum<E>> boolean isValidEnumIgnoreCase(final
Class<E> enumClass, final String enumName) {
- return getEnumIgnoreCase(enumClass, enumName) != null;
+ public static <E extends Enum<E>> long[] generateBitVectors(final Class<E>
enumClass, final Iterable<? extends E> values) {
+ asEnum(enumClass);
+ Validate.notNull(values);
+ final EnumSet<E> condensed = EnumSet.noneOf(enumClass);
+ for (final E constant : values) {
+ Validate.isTrue(constant != null, NULL_ELEMENTS_NOT_PERMITTED);
+ condensed.add(constant);
+ }
+ final long[] result = new long[(enumClass.getEnumConstants().length -
1) / Long.SIZE + 1];
+ for (final E value : condensed) {
+ result[value.ordinal() / Long.SIZE] |= 1L << (value.ordinal() %
Long.SIZE);
+ }
+ ArrayUtils.reverse(result);
+ return result;
}
/**
@@ -188,117 +265,65 @@ public class EnumUtils {
}
/**
- * <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>Gets the {@code List} of enums.</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>
+ * <p>This method is useful when you need a list of enums rather than an
array.</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)
+ * @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>> 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.isTrue(constant != null, NULL_ELEMENTS_NOT_PERMITTED);
- total |= 1L << constant.ordinal();
- }
- return total;
+ public static <E extends Enum<E>> List<E> getEnumList(final Class<E>
enumClass) {
+ return new ArrayList<>(Arrays.asList(enumClass.getEnumConstants()));
}
/**
- * <p>Creates a bit vector representation of the given subset of an Enum
using as many {@code long}s as needed.</p>
- *
- * <p>This generates a value that is usable by {@link
EnumUtils#processBitVectors}.</p>
+ * <p>Gets the {@code Map} of enums by name.</p>
*
- * <p>Use this method if you have more than 64 values in your Enum.</p>
+ * <p>This method is useful when you need a map of enums by name.</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 values provide a binary representation of the
given set of enum values
- * with least significant digits rightmost.
- * @throws NullPointerException if {@code enumClass} or {@code values} is
{@code null}
- * @throws IllegalArgumentException if {@code enumClass} is not an enum
class, or if any {@code values} {@code null}
- * @since 3.2
+ * @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>> long[] generateBitVectors(final Class<E>
enumClass, final Iterable<? extends E> values) {
- asEnum(enumClass);
- Validate.notNull(values);
- final EnumSet<E> condensed = EnumSet.noneOf(enumClass);
- for (final E constant : values) {
- Validate.isTrue(constant != null, NULL_ELEMENTS_NOT_PERMITTED);
- condensed.add(constant);
- }
- final long[] result = new long[(enumClass.getEnumConstants().length -
1) / Long.SIZE + 1];
- for (final E value : condensed) {
- result[value.ordinal() / Long.SIZE] |= 1L << (value.ordinal() %
Long.SIZE);
+ 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);
}
- ArrayUtils.reverse(result);
- return result;
+ return map;
}
/**
- * <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>Checks if the specified name is a valid enum for the class.</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>
+ * <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 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)
+ * @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
*/
- @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));
+ public static <E extends Enum<E>> boolean isValidEnum(final Class<E>
enumClass, final String enumName) {
+ return getEnum(enumClass, enumName) != null;
}
/**
- * <p>Creates a bit vector representation of the given subset of an Enum
using as many {@code long}s as needed.</p>
- *
- * <p>This generates a value that is usable by {@link
EnumUtils#processBitVectors}.</p>
+ * <p>Checks if the specified name is a valid enum for the class.</p>
*
- * <p>Use this method if you have more than 64 values in your Enum.</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 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 values provide a binary representation of the
given set of enum values
- * with least significant digits rightmost.
- * @throws NullPointerException if {@code enumClass} or {@code values} is
{@code null}
- * @throws IllegalArgumentException if {@code enumClass} is not an enum
class, or if any {@code values} {@code null}
- * @since 3.2
+ * @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
*/
- @SafeVarargs
- public static <E extends Enum<E>> long[] generateBitVectors(final Class<E>
enumClass, final E... values) {
- asEnum(enumClass);
- Validate.noNullElements(values);
- final EnumSet<E> condensed = EnumSet.noneOf(enumClass);
- Collections.addAll(condensed, values);
- final long[] result = new long[(enumClass.getEnumConstants().length -
1) / Long.SIZE + 1];
- for (final E value : condensed) {
- result[value.ordinal() / Long.SIZE] |= 1L << (value.ordinal() %
Long.SIZE);
- }
- ArrayUtils.reverse(result);
- return result;
+ public static <E extends Enum<E>> boolean isValidEnumIgnoreCase(final
Class<E> enumClass, final String enumName) {
+ return getEnumIgnoreCase(enumClass, enumName) != null;
}
/**
@@ -346,34 +371,9 @@ public class EnumUtils {
}
/**
- * 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;
- }
-
- /**
- * 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
+ * This constructor is public to permit tools that require a JavaBean
+ * instance to operate.
*/
- 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;
+ public EnumUtils() {
}
}