Hi.
Le mer. 12 juil. 2023 à 14:44, <ggreg...@apache.org> a écrit :
>
> 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
>
> commit 2e3feda04337baa483bc26b66f238161dc6c97ac
> Author: Gary Gregory <garydgreg...@gmail.com>
> AuthorDate: Wed Jul 12 08:44:38 2023 -0400
>
> Throw IllegalArgumentException instead of InternalError in the builder
> package
The diff below contains a bunch of (formatting ?) changes that
have nothing to do with this commit message.
Regards,
Gilles
> ---
> src/changes/changes.xml | 1 +
> .../commons/lang3/builder/CompareToBuilder.java | 752
> ++++++++++-----------
> .../commons/lang3/builder/EqualsBuilder.java | 20 +-
> .../commons/lang3/builder/HashCodeBuilder.java | 9 +-
> .../apache/commons/lang3/builder/Reflection.java | 44 ++
> .../lang3/builder/ReflectionDiffBuilder.java | 7 +-
> .../lang3/builder/ReflectionToStringBuilder.java | 14 +-
> 7 files changed, 434 insertions(+), 413 deletions(-)
>
> diff --git a/src/changes/changes.xml b/src/changes/changes.xml
> index 26d7be48c..da3522029 100644
> --- a/src/changes/changes.xml
> +++ b/src/changes/changes.xml
> @@ -123,6 +123,7 @@ The <action> type attribute can be add,update,fix,remove.
> <action type="fix" dev="ggregory" due-to="Dimitrios
> Efthymiou">Update Javadoc for the insert methods in ArrayUtils #1078.</action>
> <action type="fix" dev="ggregory" due-to="Gary
> Gregory">Deprecate ExceptionUtils.ExceptionUtils().</action>
> <action issue="LANG-1697" type="fix" dev="ggregory" due-to="Jan Arne
> Sparka, Gary Gregory">TypeUtils.getRawType() throws a NullPointerException on
> Wildcard GenericArrayType.</action>
> + <action type="fix" dev="ggregory" due-to="Gary
> Gregory">Throw IllegalArgumentException instead of InternalError in the
> builder package.</action>
> <!-- ADD -->
> <action type="add" dev="ggregory" due-to="Gary
> Gregory">Add GitHub coverage.yml.</action>
> <action type="add" dev="ggregory" due-to="Gary
> Gregory">Add EnumUtils.getEnumSystemProperty(...).</action>
> diff --git
> a/src/main/java/org/apache/commons/lang3/builder/CompareToBuilder.java
> b/src/main/java/org/apache/commons/lang3/builder/CompareToBuilder.java
> index 38c69e613..3d411bb15 100644
> --- a/src/main/java/org/apache/commons/lang3/builder/CompareToBuilder.java
> +++ b/src/main/java/org/apache/commons/lang3/builder/CompareToBuilder.java
> @@ -97,19 +97,37 @@ import org.apache.commons.lang3.ObjectUtils;
> public class CompareToBuilder implements Builder<Integer> {
>
> /**
> - * Current state of the comparison as appended fields are checked.
> - */
> - private int comparison;
> -
> - /**
> - * Constructor for CompareToBuilder.
> + * Appends to {@code builder} the comparison of {@code lhs}
> + * to {@code rhs} using the fields defined in {@code clazz}.
> *
> - * <p>Starts off assuming that the objects are equal. Multiple calls are
> - * then made to the various append methods, followed by a call to
> - * {@link #toComparison} to get the result.</p>
> + * @param lhs left-hand object
> + * @param rhs right-hand object
> + * @param clazz {@link Class} that defines fields to be compared
> + * @param builder {@link CompareToBuilder} to append to
> + * @param useTransients whether to compare transient fields
> + * @param excludeFields fields to exclude
> */
> - public CompareToBuilder() {
> - comparison = 0;
> + private static void reflectionAppend(
> + final Object lhs,
> + final Object rhs,
> + final Class<?> clazz,
> + final CompareToBuilder builder,
> + final boolean useTransients,
> + final String[] excludeFields) {
> +
> + final Field[] fields = clazz.getDeclaredFields();
> + AccessibleObject.setAccessible(fields, true);
> + for (int i = 0; i < fields.length && builder.comparison == 0; i++) {
> + final Field field = fields[i];
> + if (!ArrayUtils.contains(excludeFields, field.getName())
> + && !field.getName().contains("$")
> + && (useTransients ||
> !Modifier.isTransient(field.getModifiers()))
> + && !Modifier.isStatic(field.getModifiers())) {
> + // IllegalAccessException can't happen. Would get a Security
> exception instead.
> + // Throw a runtime exception in case the impossible happens.
> + builder.append(Reflection.getUnchecked(field, lhs),
> Reflection.getUnchecked(field, rhs));
> + }
> + }
> }
>
> /**
> @@ -183,10 +201,11 @@ public class CompareToBuilder implements
> Builder<Integer> {
> *
> * <ul>
> * <li>Static fields will not be compared</li>
> - * <li>If {@code compareTransients} is {@code true},
> + * <li>If the {@code compareTransients} is {@code true},
> * compares transient members. Otherwise ignores them, as they
> * are likely derived fields.</li>
> - * <li>Superclass fields will be compared</li>
> + * <li>Compares superclass fields up to and including {@code
> reflectUpToClass}.
> + * If {@code reflectUpToClass} is {@code null}, compares all
> superclass fields.</li>
> * </ul>
> *
> * <p>If both {@code lhs} and {@code rhs} are {@code null},
> @@ -194,17 +213,41 @@ public class CompareToBuilder implements
> Builder<Integer> {
> *
> * @param lhs left-hand object
> * @param rhs right-hand object
> - * @param excludeFields Collection of String fields to exclude
> + * @param compareTransients whether to compare transient fields
> + * @param reflectUpToClass last superclass for which fields are compared
> + * @param excludeFields fields to exclude
> * @return a negative integer, zero, or a positive integer as {@code lhs}
> * is less than, equal to, or greater than {@code rhs}
> * @throws NullPointerException if either {@code lhs} or {@code rhs}
> * (but not both) is {@code null}
> * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> * with {@code lhs}
> - * @since 2.2
> + * @since 2.2 (2.0 as {@code reflectionCompare(Object, Object, boolean,
> Class)})
> */
> - public static int reflectionCompare(final Object lhs, final Object rhs,
> final Collection<String> excludeFields) {
> - return reflectionCompare(lhs, rhs,
> ReflectionToStringBuilder.toNoNullStringArray(excludeFields));
> + public static int reflectionCompare(
> + final Object lhs,
> + final Object rhs,
> + final boolean compareTransients,
> + final Class<?> reflectUpToClass,
> + final String... excludeFields) {
> +
> + if (lhs == rhs) {
> + return 0;
> + }
> + Objects.requireNonNull(lhs, "lhs");
> + Objects.requireNonNull(rhs, "rhs");
> +
> + Class<?> lhsClazz = lhs.getClass();
> + if (!lhsClazz.isInstance(rhs)) {
> + throw new ClassCastException();
> + }
> + final CompareToBuilder compareToBuilder = new CompareToBuilder();
> + reflectionAppend(lhs, rhs, lhsClazz, compareToBuilder,
> compareTransients, excludeFields);
> + while (lhsClazz.getSuperclass() != null && lhsClazz !=
> reflectUpToClass) {
> + lhsClazz = lhsClazz.getSuperclass();
> + reflectionAppend(lhs, rhs, lhsClazz, compareToBuilder,
> compareTransients, excludeFields);
> + }
> + return compareToBuilder.toComparison();
> }
>
> /**
> @@ -227,7 +270,7 @@ public class CompareToBuilder implements Builder<Integer>
> {
> *
> * @param lhs left-hand object
> * @param rhs right-hand object
> - * @param excludeFields array of fields to exclude
> + * @param excludeFields Collection of String fields to exclude
> * @return a negative integer, zero, or a positive integer as {@code lhs}
> * is less than, equal to, or greater than {@code rhs}
> * @throws NullPointerException if either {@code lhs} or {@code rhs}
> @@ -236,8 +279,8 @@ public class CompareToBuilder implements Builder<Integer>
> {
> * with {@code lhs}
> * @since 2.2
> */
> - public static int reflectionCompare(final Object lhs, final Object rhs,
> final String... excludeFields) {
> - return reflectionCompare(lhs, rhs, false, null, excludeFields);
> + public static int reflectionCompare(final Object lhs, final Object rhs,
> final Collection<String> excludeFields) {
> + return reflectionCompare(lhs, rhs,
> ReflectionToStringBuilder.toNoNullStringArray(excludeFields));
> }
>
> /**
> @@ -249,11 +292,10 @@ public class CompareToBuilder implements
> Builder<Integer> {
> *
> * <ul>
> * <li>Static fields will not be compared</li>
> - * <li>If the {@code compareTransients} is {@code true},
> + * <li>If {@code compareTransients} is {@code true},
> * compares transient members. Otherwise ignores them, as they
> * are likely derived fields.</li>
> - * <li>Compares superclass fields up to and including {@code
> reflectUpToClass}.
> - * If {@code reflectUpToClass} is {@code null}, compares all
> superclass fields.</li>
> + * <li>Superclass fields will be compared</li>
> * </ul>
> *
> * <p>If both {@code lhs} and {@code rhs} are {@code null},
> @@ -261,146 +303,74 @@ public class CompareToBuilder implements
> Builder<Integer> {
> *
> * @param lhs left-hand object
> * @param rhs right-hand object
> - * @param compareTransients whether to compare transient fields
> - * @param reflectUpToClass last superclass for which fields are compared
> - * @param excludeFields fields to exclude
> + * @param excludeFields array of fields to exclude
> * @return a negative integer, zero, or a positive integer as {@code lhs}
> * is less than, equal to, or greater than {@code rhs}
> * @throws NullPointerException if either {@code lhs} or {@code rhs}
> * (but not both) is {@code null}
> * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> * with {@code lhs}
> - * @since 2.2 (2.0 as {@code reflectionCompare(Object, Object, boolean,
> Class)})
> + * @since 2.2
> */
> - public static int reflectionCompare(
> - final Object lhs,
> - final Object rhs,
> - final boolean compareTransients,
> - final Class<?> reflectUpToClass,
> - final String... excludeFields) {
> -
> - if (lhs == rhs) {
> - return 0;
> - }
> - Objects.requireNonNull(lhs, "lhs");
> - Objects.requireNonNull(rhs, "rhs");
> -
> - Class<?> lhsClazz = lhs.getClass();
> - if (!lhsClazz.isInstance(rhs)) {
> - throw new ClassCastException();
> - }
> - final CompareToBuilder compareToBuilder = new CompareToBuilder();
> - reflectionAppend(lhs, rhs, lhsClazz, compareToBuilder,
> compareTransients, excludeFields);
> - while (lhsClazz.getSuperclass() != null && lhsClazz !=
> reflectUpToClass) {
> - lhsClazz = lhsClazz.getSuperclass();
> - reflectionAppend(lhs, rhs, lhsClazz, compareToBuilder,
> compareTransients, excludeFields);
> - }
> - return compareToBuilder.toComparison();
> + public static int reflectionCompare(final Object lhs, final Object rhs,
> final String... excludeFields) {
> + return reflectionCompare(lhs, rhs, false, null, excludeFields);
> }
>
> /**
> - * Appends to {@code builder} the comparison of {@code lhs}
> - * to {@code rhs} using the fields defined in {@code clazz}.
> - *
> - * @param lhs left-hand object
> - * @param rhs right-hand object
> - * @param clazz {@link Class} that defines fields to be compared
> - * @param builder {@link CompareToBuilder} to append to
> - * @param useTransients whether to compare transient fields
> - * @param excludeFields fields to exclude
> + * Current state of the comparison as appended fields are checked.
> */
> - private static void reflectionAppend(
> - final Object lhs,
> - final Object rhs,
> - final Class<?> clazz,
> - final CompareToBuilder builder,
> - final boolean useTransients,
> - final String[] excludeFields) {
> -
> - final Field[] fields = clazz.getDeclaredFields();
> - AccessibleObject.setAccessible(fields, true);
> - for (int i = 0; i < fields.length && builder.comparison == 0; i++) {
> - final Field field = fields[i];
> - if (!ArrayUtils.contains(excludeFields, field.getName())
> - && !field.getName().contains("$")
> - && (useTransients ||
> !Modifier.isTransient(field.getModifiers()))
> - && !Modifier.isStatic(field.getModifiers())) {
> - try {
> - builder.append(field.get(lhs), field.get(rhs));
> - } catch (final IllegalAccessException e) {
> - // This can't happen. Would get a Security exception
> instead.
> - // Throw a runtime exception in case the impossible
> happens.
> - throw new InternalError("Unexpected
> IllegalAccessException");
> - }
> - }
> - }
> - }
> + private int comparison;
>
> /**
> - * Appends to the {@code builder} the {@code compareTo(Object)}
> - * result of the superclass.
> + * Constructor for CompareToBuilder.
> *
> - * @param superCompareTo result of calling {@code
> super.compareTo(Object)}
> - * @return this
> - * @since 2.0
> + * <p>Starts off assuming that the objects are equal. Multiple calls are
> + * then made to the various append methods, followed by a call to
> + * {@link #toComparison} to get the result.</p>
> */
> - public CompareToBuilder appendSuper(final int superCompareTo) {
> - if (comparison != 0) {
> - return this;
> - }
> - comparison = superCompareTo;
> - return this;
> + public CompareToBuilder() {
> + comparison = 0;
> }
>
> /**
> * Appends to the {@code builder} the comparison of
> - * two {@link Object}s.
> - *
> - * <ol>
> - * <li>Check if {@code lhs == rhs}</li>
> - * <li>Check if either {@code lhs} or {@code rhs} is {@code null},
> - * a {@code null} object is less than a non-{@code null} object</li>
> - * <li>Check the object contents</li>
> - * </ol>
> - *
> - * <p>{@code lhs} must either be an array or implement {@link
> Comparable}.</p>
> + * two {@code booleans}s.
> *
> - * @param lhs left-hand object
> - * @param rhs right-hand object
> + * @param lhs left-hand value
> + * @param rhs right-hand value
> * @return this
> - * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> - * with {@code lhs}
> - */
> - public CompareToBuilder append(final Object lhs, final Object rhs) {
> - return append(lhs, rhs, null);
> + */
> + public CompareToBuilder append(final boolean lhs, final boolean rhs) {
> + if (comparison != 0) {
> + return this;
> + }
> + if (lhs == rhs) {
> + return this;
> + }
> + if (lhs) {
> + comparison = 1;
> + } else {
> + comparison = -1;
> + }
> + return this;
> }
>
> /**
> - * Appends to the {@code builder} the comparison of
> - * two {@link Object}s.
> + * Appends to the {@code builder} the deep comparison of
> + * two {@code boolean} arrays.
> *
> * <ol>
> - * <li>Check if {@code lhs == rhs}</li>
> - * <li>Check if either {@code lhs} or {@code rhs} is {@code null},
> - * a {@code null} object is less than a non-{@code null} object</li>
> - * <li>Check the object contents</li>
> + * <li>Check if arrays are the same using {@code ==}</li>
> + * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> + * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> + * <li>Check array contents element by element using {@link
> #append(boolean, boolean)}</li>
> * </ol>
> *
> - * <p>If {@code lhs} is an array, array comparison methods will be used.
> - * Otherwise {@code comparator} will be used to compare the objects.
> - * If {@code comparator} is {@code null}, {@code lhs} must
> - * implement {@link Comparable} instead.</p>
> - *
> - * @param lhs left-hand object
> - * @param rhs right-hand object
> - * @param comparator {@link Comparator} used to compare the objects,
> - * {@code null} means treat lhs as {@link Comparable}
> + * @param lhs left-hand array
> + * @param rhs right-hand array
> * @return this
> - * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> - * with {@code lhs}
> - * @since 2.0
> */
> - public CompareToBuilder append(final Object lhs, final Object rhs, final
> Comparator<?> comparator) {
> + public CompareToBuilder append(final boolean[] lhs, final boolean[] rhs)
> {
> if (comparison != 0) {
> return this;
> }
> @@ -415,94 +385,69 @@ public class CompareToBuilder implements
> Builder<Integer> {
> comparison = 1;
> return this;
> }
> - if (ObjectUtils.isArray(lhs)) {
> - // factor out array case in order to keep method small enough to
> be inlined
> - appendArray(lhs, rhs, comparator);
> - } else // the simple case, not an array, just test the element
> - if (comparator == null) {
> - @SuppressWarnings("unchecked") // assume this can be done; if
> not throw CCE as per Javadoc
> - final Comparable<Object> comparable = (Comparable<Object>) lhs;
> - comparison = comparable.compareTo(rhs);
> - } else {
> - @SuppressWarnings("unchecked") // assume this can be done; if
> not throw CCE as per Javadoc
> - final Comparator<Object> comparator2 = (Comparator<Object>)
> comparator;
> - comparison = comparator2.compare(lhs, rhs);
> + if (lhs.length != rhs.length) {
> + comparison = lhs.length < rhs.length ? -1 : 1;
> + return this;
> }
> - return this;
> - }
> -
> - private void appendArray(final Object lhs, final Object rhs, final
> Comparator<?> comparator) {
> - // switch on type of array, to dispatch to the correct handler
> - // handles multidimensional arrays
> - // throws a ClassCastException if rhs is not the correct array type
> - if (lhs instanceof long[]) {
> - append((long[]) lhs, (long[]) rhs);
> - } else if (lhs instanceof int[]) {
> - append((int[]) lhs, (int[]) rhs);
> - } else if (lhs instanceof short[]) {
> - append((short[]) lhs, (short[]) rhs);
> - } else if (lhs instanceof char[]) {
> - append((char[]) lhs, (char[]) rhs);
> - } else if (lhs instanceof byte[]) {
> - append((byte[]) lhs, (byte[]) rhs);
> - } else if (lhs instanceof double[]) {
> - append((double[]) lhs, (double[]) rhs);
> - } else if (lhs instanceof float[]) {
> - append((float[]) lhs, (float[]) rhs);
> - } else if (lhs instanceof boolean[]) {
> - append((boolean[]) lhs, (boolean[]) rhs);
> - } else {
> - // not an array of primitives
> - // throws a ClassCastException if rhs is not an array
> - append((Object[]) lhs, (Object[]) rhs, comparator);
> + for (int i = 0; i < lhs.length && comparison == 0; i++) {
> + append(lhs[i], rhs[i]);
> }
> + return this;
> }
>
> /**
> * Appends to the {@code builder} the comparison of
> - * two {@code long}s.
> + * two {@code byte}s.
> *
> * @param lhs left-hand value
> * @param rhs right-hand value
> * @return this
> */
> - public CompareToBuilder append(final long lhs, final long rhs) {
> + public CompareToBuilder append(final byte lhs, final byte rhs) {
> if (comparison != 0) {
> return this;
> }
> - comparison = Long.compare(lhs, rhs);
> + comparison = Byte.compare(lhs, rhs);
> return this;
> }
>
> /**
> - * Appends to the {@code builder} the comparison of
> - * two {@code int}s.
> + * Appends to the {@code builder} the deep comparison of
> + * two {@code byte} arrays.
> *
> - * @param lhs left-hand value
> - * @param rhs right-hand value
> + * <ol>
> + * <li>Check if arrays are the same using {@code ==}</li>
> + * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> + * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> + * <li>Check array contents element by element using {@link
> #append(byte, byte)}</li>
> + * </ol>
> + *
> + * @param lhs left-hand array
> + * @param rhs right-hand array
> * @return this
> */
> - public CompareToBuilder append(final int lhs, final int rhs) {
> + public CompareToBuilder append(final byte[] lhs, final byte[] rhs) {
> if (comparison != 0) {
> return this;
> }
> - comparison = Integer.compare(lhs, rhs);
> - return this;
> - }
> -
> - /**
> - * Appends to the {@code builder} the comparison of
> - * two {@code short}s.
> - *
> - * @param lhs left-hand value
> - * @param rhs right-hand value
> - * @return this
> - */
> - public CompareToBuilder append(final short lhs, final short rhs) {
> - if (comparison != 0) {
> + if (lhs == rhs) {
> return this;
> }
> - comparison = Short.compare(lhs, rhs);
> + if (lhs == null) {
> + comparison = -1;
> + return this;
> + }
> + if (rhs == null) {
> + comparison = 1;
> + return this;
> + }
> + if (lhs.length != rhs.length) {
> + comparison = lhs.length < rhs.length ? -1 : 1;
> + return this;
> + }
> + for (int i = 0; i < lhs.length && comparison == 0; i++) {
> + append(lhs[i], rhs[i]);
> + }
> return this;
> }
>
> @@ -523,18 +468,42 @@ public class CompareToBuilder implements
> Builder<Integer> {
> }
>
> /**
> - * Appends to the {@code builder} the comparison of
> - * two {@code byte}s.
> + * Appends to the {@code builder} the deep comparison of
> + * two {@code char} arrays.
> *
> - * @param lhs left-hand value
> - * @param rhs right-hand value
> + * <ol>
> + * <li>Check if arrays are the same using {@code ==}</li>
> + * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> + * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> + * <li>Check array contents element by element using {@link
> #append(char, char)}</li>
> + * </ol>
> + *
> + * @param lhs left-hand array
> + * @param rhs right-hand array
> * @return this
> */
> - public CompareToBuilder append(final byte lhs, final byte rhs) {
> + public CompareToBuilder append(final char[] lhs, final char[] rhs) {
> if (comparison != 0) {
> return this;
> }
> - comparison = Byte.compare(lhs, rhs);
> + if (lhs == rhs) {
> + return this;
> + }
> + if (lhs == null) {
> + comparison = -1;
> + return this;
> + }
> + if (rhs == null) {
> + comparison = 1;
> + return this;
> + }
> + if (lhs.length != rhs.length) {
> + comparison = lhs.length < rhs.length ? -1 : 1;
> + return this;
> + }
> + for (int i = 0; i < lhs.length && comparison == 0; i++) {
> + append(lhs[i], rhs[i]);
> + }
> return this;
> }
>
> @@ -559,98 +528,22 @@ public class CompareToBuilder implements
> Builder<Integer> {
> return this;
> }
>
> - /**
> - * Appends to the {@code builder} the comparison of
> - * two {@code float}s.
> - *
> - * <p>This handles NaNs, Infinities, and {@code -0.0}.</p>
> - *
> - * <p>It is compatible with the hash code generated by
> - * {@link HashCodeBuilder}.</p>
> - *
> - * @param lhs left-hand value
> - * @param rhs right-hand value
> - * @return this
> - */
> - public CompareToBuilder append(final float lhs, final float rhs) {
> - if (comparison != 0) {
> - return this;
> - }
> - comparison = Float.compare(lhs, rhs);
> - return this;
> - }
> -
> - /**
> - * Appends to the {@code builder} the comparison of
> - * two {@code booleans}s.
> - *
> - * @param lhs left-hand value
> - * @param rhs right-hand value
> - * @return this
> - */
> - public CompareToBuilder append(final boolean lhs, final boolean rhs) {
> - if (comparison != 0) {
> - return this;
> - }
> - if (lhs == rhs) {
> - return this;
> - }
> - if (lhs) {
> - comparison = 1;
> - } else {
> - comparison = -1;
> - }
> - return this;
> - }
> -
> /**
> * Appends to the {@code builder} the deep comparison of
> - * two {@link Object} arrays.
> - *
> - * <ol>
> - * <li>Check if arrays are the same using {@code ==}</li>
> - * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> - * <li>Check array length, a short length array is less than a long
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(Object, Object, Comparator)}</li>
> - * </ol>
> - *
> - * <p>This method will also will be called for the top level of
> multi-dimensional,
> - * ragged, and multi-typed arrays.</p>
> - *
> - * @param lhs left-hand array
> - * @param rhs right-hand array
> - * @return this
> - * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> - * with {@code lhs}
> - */
> - public CompareToBuilder append(final Object[] lhs, final Object[] rhs) {
> - return append(lhs, rhs, null);
> - }
> -
> - /**
> - * Appends to the {@code builder} the deep comparison of
> - * two {@link Object} arrays.
> + * two {@code double} arrays.
> *
> * <ol>
> * <li>Check if arrays are the same using {@code ==}</li>
> * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> - * <li>Check array length, a short length array is less than a long
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(Object, Object, Comparator)}</li>
> + * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> + * <li>Check array contents element by element using {@link
> #append(double, double)}</li>
> * </ol>
> *
> - * <p>This method will also will be called for the top level of
> multi-dimensional,
> - * ragged, and multi-typed arrays.</p>
> - *
> * @param lhs left-hand array
> * @param rhs right-hand array
> - * @param comparator {@link Comparator} to use to compare the array
> elements,
> - * {@code null} means to treat {@code lhs} elements as {@link
> Comparable}.
> * @return this
> - * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> - * with {@code lhs}
> - * @since 2.0
> */
> - public CompareToBuilder append(final Object[] lhs, final Object[] rhs,
> final Comparator<?> comparator) {
> + public CompareToBuilder append(final double[] lhs, final double[] rhs) {
> if (comparison != 0) {
> return this;
> }
> @@ -670,67 +563,48 @@ public class CompareToBuilder implements
> Builder<Integer> {
> return this;
> }
> for (int i = 0; i < lhs.length && comparison == 0; i++) {
> - append(lhs[i], rhs[i], comparator);
> + append(lhs[i], rhs[i]);
> }
> return this;
> }
>
> /**
> - * Appends to the {@code builder} the deep comparison of
> - * two {@code long} arrays.
> + * Appends to the {@code builder} the comparison of
> + * two {@code float}s.
> *
> - * <ol>
> - * <li>Check if arrays are the same using {@code ==}</li>
> - * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> - * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(long, long)}</li>
> - * </ol>
> + * <p>This handles NaNs, Infinities, and {@code -0.0}.</p>
> *
> - * @param lhs left-hand array
> - * @param rhs right-hand array
> + * <p>It is compatible with the hash code generated by
> + * {@link HashCodeBuilder}.</p>
> + *
> + * @param lhs left-hand value
> + * @param rhs right-hand value
> * @return this
> */
> - public CompareToBuilder append(final long[] lhs, final long[] rhs) {
> + public CompareToBuilder append(final float lhs, final float rhs) {
> if (comparison != 0) {
> - return this;
> - }
> - if (lhs == rhs) {
> - return this;
> - }
> - if (lhs == null) {
> - comparison = -1;
> - return this;
> - }
> - if (rhs == null) {
> - comparison = 1;
> - return this;
> - }
> - if (lhs.length != rhs.length) {
> - comparison = lhs.length < rhs.length ? -1 : 1;
> - return this;
> - }
> - for (int i = 0; i < lhs.length && comparison == 0; i++) {
> - append(lhs[i], rhs[i]);
> + return this;
> }
> + comparison = Float.compare(lhs, rhs);
> return this;
> }
>
> /**
> * Appends to the {@code builder} the deep comparison of
> - * two {@code int} arrays.
> + * two {@code float} arrays.
> *
> * <ol>
> * <li>Check if arrays are the same using {@code ==}</li>
> * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(int, int)}</li>
> + * <li>Check array contents element by element using {@link
> #append(float, float)}</li>
> * </ol>
> *
> * @param lhs left-hand array
> * @param rhs right-hand array
> * @return this
> */
> - public CompareToBuilder append(final int[] lhs, final int[] rhs) {
> + public CompareToBuilder append(final float[] lhs, final float[] rhs) {
> if (comparison != 0) {
> return this;
> }
> @@ -755,22 +629,38 @@ public class CompareToBuilder implements
> Builder<Integer> {
> return this;
> }
>
> + /**
> + * Appends to the {@code builder} the comparison of
> + * two {@code int}s.
> + *
> + * @param lhs left-hand value
> + * @param rhs right-hand value
> + * @return this
> + */
> + public CompareToBuilder append(final int lhs, final int rhs) {
> + if (comparison != 0) {
> + return this;
> + }
> + comparison = Integer.compare(lhs, rhs);
> + return this;
> + }
> +
> /**
> * Appends to the {@code builder} the deep comparison of
> - * two {@code short} arrays.
> + * two {@code int} arrays.
> *
> * <ol>
> * <li>Check if arrays are the same using {@code ==}</li>
> * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(short, short)}</li>
> + * <li>Check array contents element by element using {@link
> #append(int, int)}</li>
> * </ol>
> *
> * @param lhs left-hand array
> * @param rhs right-hand array
> * @return this
> */
> - public CompareToBuilder append(final short[] lhs, final short[] rhs) {
> + public CompareToBuilder append(final int[] lhs, final int[] rhs) {
> if (comparison != 0) {
> return this;
> }
> @@ -795,22 +685,38 @@ public class CompareToBuilder implements
> Builder<Integer> {
> return this;
> }
>
> + /**
> + * Appends to the {@code builder} the comparison of
> + * two {@code long}s.
> + *
> + * @param lhs left-hand value
> + * @param rhs right-hand value
> + * @return this
> + */
> + public CompareToBuilder append(final long lhs, final long rhs) {
> + if (comparison != 0) {
> + return this;
> + }
> + comparison = Long.compare(lhs, rhs);
> + return this;
> + }
> +
> /**
> * Appends to the {@code builder} the deep comparison of
> - * two {@code char} arrays.
> + * two {@code long} arrays.
> *
> * <ol>
> * <li>Check if arrays are the same using {@code ==}</li>
> * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(char, char)}</li>
> + * <li>Check array contents element by element using {@link
> #append(long, long)}</li>
> * </ol>
> *
> * @param lhs left-hand array
> * @param rhs right-hand array
> * @return this
> */
> - public CompareToBuilder append(final char[] lhs, final char[] rhs) {
> + public CompareToBuilder append(final long[] lhs, final long[] rhs) {
> if (comparison != 0) {
> return this;
> }
> @@ -836,21 +742,54 @@ public class CompareToBuilder implements
> Builder<Integer> {
> }
>
> /**
> - * Appends to the {@code builder} the deep comparison of
> - * two {@code byte} arrays.
> + * Appends to the {@code builder} the comparison of
> + * two {@link Object}s.
> *
> * <ol>
> - * <li>Check if arrays are the same using {@code ==}</li>
> - * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> - * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(byte, byte)}</li>
> + * <li>Check if {@code lhs == rhs}</li>
> + * <li>Check if either {@code lhs} or {@code rhs} is {@code null},
> + * a {@code null} object is less than a non-{@code null} object</li>
> + * <li>Check the object contents</li>
> * </ol>
> *
> - * @param lhs left-hand array
> - * @param rhs right-hand array
> + * <p>{@code lhs} must either be an array or implement {@link
> Comparable}.</p>
> + *
> + * @param lhs left-hand object
> + * @param rhs right-hand object
> * @return this
> + * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> + * with {@code lhs}
> */
> - public CompareToBuilder append(final byte[] lhs, final byte[] rhs) {
> + public CompareToBuilder append(final Object lhs, final Object rhs) {
> + return append(lhs, rhs, null);
> + }
> +
> + /**
> + * Appends to the {@code builder} the comparison of
> + * two {@link Object}s.
> + *
> + * <ol>
> + * <li>Check if {@code lhs == rhs}</li>
> + * <li>Check if either {@code lhs} or {@code rhs} is {@code null},
> + * a {@code null} object is less than a non-{@code null} object</li>
> + * <li>Check the object contents</li>
> + * </ol>
> + *
> + * <p>If {@code lhs} is an array, array comparison methods will be used.
> + * Otherwise {@code comparator} will be used to compare the objects.
> + * If {@code comparator} is {@code null}, {@code lhs} must
> + * implement {@link Comparable} instead.</p>
> + *
> + * @param lhs left-hand object
> + * @param rhs right-hand object
> + * @param comparator {@link Comparator} used to compare the objects,
> + * {@code null} means treat lhs as {@link Comparable}
> + * @return this
> + * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> + * with {@code lhs}
> + * @since 2.0
> + */
> + public CompareToBuilder append(final Object lhs, final Object rhs, final
> Comparator<?> comparator) {
> if (comparison != 0) {
> return this;
> }
> @@ -865,72 +804,70 @@ public class CompareToBuilder implements
> Builder<Integer> {
> comparison = 1;
> return this;
> }
> - if (lhs.length != rhs.length) {
> - comparison = lhs.length < rhs.length ? -1 : 1;
> - return this;
> - }
> - for (int i = 0; i < lhs.length && comparison == 0; i++) {
> - append(lhs[i], rhs[i]);
> + if (ObjectUtils.isArray(lhs)) {
> + // factor out array case in order to keep method small enough to
> be inlined
> + appendArray(lhs, rhs, comparator);
> + } else // the simple case, not an array, just test the element
> + if (comparator == null) {
> + @SuppressWarnings("unchecked") // assume this can be done; if
> not throw CCE as per Javadoc
> + final Comparable<Object> comparable = (Comparable<Object>) lhs;
> + comparison = comparable.compareTo(rhs);
> + } else {
> + @SuppressWarnings("unchecked") // assume this can be done; if
> not throw CCE as per Javadoc
> + final Comparator<Object> comparator2 = (Comparator<Object>)
> comparator;
> + comparison = comparator2.compare(lhs, rhs);
> }
> return this;
> }
>
> /**
> * Appends to the {@code builder} the deep comparison of
> - * two {@code double} arrays.
> + * two {@link Object} arrays.
> *
> * <ol>
> * <li>Check if arrays are the same using {@code ==}</li>
> * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> - * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(double, double)}</li>
> + * <li>Check array length, a short length array is less than a long
> length array</li>
> + * <li>Check array contents element by element using {@link
> #append(Object, Object, Comparator)}</li>
> * </ol>
> *
> + * <p>This method will also will be called for the top level of
> multi-dimensional,
> + * ragged, and multi-typed arrays.</p>
> + *
> * @param lhs left-hand array
> * @param rhs right-hand array
> * @return this
> + * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> + * with {@code lhs}
> */
> - public CompareToBuilder append(final double[] lhs, final double[] rhs) {
> - if (comparison != 0) {
> - return this;
> - }
> - if (lhs == rhs) {
> - return this;
> - }
> - if (lhs == null) {
> - comparison = -1;
> - return this;
> - }
> - if (rhs == null) {
> - comparison = 1;
> - return this;
> - }
> - if (lhs.length != rhs.length) {
> - comparison = lhs.length < rhs.length ? -1 : 1;
> - return this;
> - }
> - for (int i = 0; i < lhs.length && comparison == 0; i++) {
> - append(lhs[i], rhs[i]);
> - }
> - return this;
> + public CompareToBuilder append(final Object[] lhs, final Object[] rhs) {
> + return append(lhs, rhs, null);
> }
>
> /**
> * Appends to the {@code builder} the deep comparison of
> - * two {@code float} arrays.
> + * two {@link Object} arrays.
> *
> * <ol>
> * <li>Check if arrays are the same using {@code ==}</li>
> * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> - * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(float, float)}</li>
> + * <li>Check array length, a short length array is less than a long
> length array</li>
> + * <li>Check array contents element by element using {@link
> #append(Object, Object, Comparator)}</li>
> * </ol>
> *
> + * <p>This method will also will be called for the top level of
> multi-dimensional,
> + * ragged, and multi-typed arrays.</p>
> + *
> * @param lhs left-hand array
> * @param rhs right-hand array
> + * @param comparator {@link Comparator} to use to compare the array
> elements,
> + * {@code null} means to treat {@code lhs} elements as {@link
> Comparable}.
> * @return this
> + * @throws ClassCastException if {@code rhs} is not
> assignment-compatible
> + * with {@code lhs}
> + * @since 2.0
> */
> - public CompareToBuilder append(final float[] lhs, final float[] rhs) {
> + public CompareToBuilder append(final Object[] lhs, final Object[] rhs,
> final Comparator<?> comparator) {
> if (comparison != 0) {
> return this;
> }
> @@ -950,27 +887,43 @@ public class CompareToBuilder implements
> Builder<Integer> {
> return this;
> }
> for (int i = 0; i < lhs.length && comparison == 0; i++) {
> - append(lhs[i], rhs[i]);
> + append(lhs[i], rhs[i], comparator);
> + }
> + return this;
> + }
> +
> + /**
> + * Appends to the {@code builder} the comparison of
> + * two {@code short}s.
> + *
> + * @param lhs left-hand value
> + * @param rhs right-hand value
> + * @return this
> + */
> + public CompareToBuilder append(final short lhs, final short rhs) {
> + if (comparison != 0) {
> + return this;
> }
> + comparison = Short.compare(lhs, rhs);
> return this;
> }
>
> /**
> * Appends to the {@code builder} the deep comparison of
> - * two {@code boolean} arrays.
> + * two {@code short} arrays.
> *
> * <ol>
> * <li>Check if arrays are the same using {@code ==}</li>
> * <li>Check if for {@code null}, {@code null} is less than non-{@code
> null}</li>
> * <li>Check array length, a shorter length array is less than a longer
> length array</li>
> - * <li>Check array contents element by element using {@link
> #append(boolean, boolean)}</li>
> + * <li>Check array contents element by element using {@link
> #append(short, short)}</li>
> * </ol>
> *
> * @param lhs left-hand array
> * @param rhs right-hand array
> * @return this
> */
> - public CompareToBuilder append(final boolean[] lhs, final boolean[] rhs)
> {
> + public CompareToBuilder append(final short[] lhs, final short[] rhs) {
> if (comparison != 0) {
> return this;
> }
> @@ -995,17 +948,47 @@ public class CompareToBuilder implements
> Builder<Integer> {
> return this;
> }
>
> + private void appendArray(final Object lhs, final Object rhs, final
> Comparator<?> comparator) {
> + // switch on type of array, to dispatch to the correct handler
> + // handles multidimensional arrays
> + // throws a ClassCastException if rhs is not the correct array type
> + if (lhs instanceof long[]) {
> + append((long[]) lhs, (long[]) rhs);
> + } else if (lhs instanceof int[]) {
> + append((int[]) lhs, (int[]) rhs);
> + } else if (lhs instanceof short[]) {
> + append((short[]) lhs, (short[]) rhs);
> + } else if (lhs instanceof char[]) {
> + append((char[]) lhs, (char[]) rhs);
> + } else if (lhs instanceof byte[]) {
> + append((byte[]) lhs, (byte[]) rhs);
> + } else if (lhs instanceof double[]) {
> + append((double[]) lhs, (double[]) rhs);
> + } else if (lhs instanceof float[]) {
> + append((float[]) lhs, (float[]) rhs);
> + } else if (lhs instanceof boolean[]) {
> + append((boolean[]) lhs, (boolean[]) rhs);
> + } else {
> + // not an array of primitives
> + // throws a ClassCastException if rhs is not an array
> + append((Object[]) lhs, (Object[]) rhs, comparator);
> + }
> + }
> +
> /**
> - * Returns a negative integer, a positive integer, or zero as
> - * the {@code builder} has judged the "left-hand" side
> - * as less than, greater than, or equal to the "right-hand"
> - * side.
> + * Appends to the {@code builder} the {@code compareTo(Object)}
> + * result of the superclass.
> *
> - * @return final comparison result
> - * @see #build()
> + * @param superCompareTo result of calling {@code
> super.compareTo(Object)}
> + * @return this
> + * @since 2.0
> */
> - public int toComparison() {
> - return comparison;
> + public CompareToBuilder appendSuper(final int superCompareTo) {
> + if (comparison != 0) {
> + return this;
> + }
> + comparison = superCompareTo;
> + return this;
> }
>
> /**
> @@ -1022,5 +1005,18 @@ public class CompareToBuilder implements
> Builder<Integer> {
> public Integer build() {
> return Integer.valueOf(toComparison());
> }
> +
> + /**
> + * Returns a negative integer, a positive integer, or zero as
> + * the {@code builder} has judged the "left-hand" side
> + * as less than, greater than, or equal to the "right-hand"
> + * side.
> + *
> + * @return final comparison result
> + * @see #build()
> + */
> + public int toComparison() {
> + return comparison;
> + }
> }
>
> diff --git
> a/src/main/java/org/apache/commons/lang3/builder/EqualsBuilder.java
> b/src/main/java/org/apache/commons/lang3/builder/EqualsBuilder.java
> index 6f843ca9e..b34e9d390 100644
> --- a/src/main/java/org/apache/commons/lang3/builder/EqualsBuilder.java
> +++ b/src/main/java/org/apache/commons/lang3/builder/EqualsBuilder.java
> @@ -561,19 +561,13 @@ public class EqualsBuilder implements Builder<Boolean> {
> final Field[] fields = clazz.getDeclaredFields();
> AccessibleObject.setAccessible(fields, true);
> for (int i = 0; i < fields.length && isEquals; i++) {
> - final Field f = fields[i];
> - if (!ArrayUtils.contains(excludeFields, f.getName())
> - && !f.getName().contains("$")
> - && (testTransients ||
> !Modifier.isTransient(f.getModifiers()))
> - && !Modifier.isStatic(f.getModifiers())
> - && !f.isAnnotationPresent(EqualsExclude.class)) {
> - try {
> - append(f.get(lhs), f.get(rhs));
> - } catch (final IllegalAccessException e) {
> - //this can't happen. Would get a Security exception
> instead
> - //throw a runtime exception in case the impossible
> happens.
> - throw new InternalError("Unexpected
> IllegalAccessException");
> - }
> + final Field field = fields[i];
> + if (!ArrayUtils.contains(excludeFields, field.getName())
> + && !field.getName().contains("$")
> + && (testTransients ||
> !Modifier.isTransient(field.getModifiers()))
> + && !Modifier.isStatic(field.getModifiers())
> + && !field.isAnnotationPresent(EqualsExclude.class)) {
> + append(Reflection.getUnchecked(field, lhs),
> Reflection.getUnchecked(field, rhs));
> }
> }
> } finally {
> diff --git
> a/src/main/java/org/apache/commons/lang3/builder/HashCodeBuilder.java
> b/src/main/java/org/apache/commons/lang3/builder/HashCodeBuilder.java
> index 9c86c76f7..afe59a8bd 100644
> --- a/src/main/java/org/apache/commons/lang3/builder/HashCodeBuilder.java
> +++ b/src/main/java/org/apache/commons/lang3/builder/HashCodeBuilder.java
> @@ -191,14 +191,7 @@ public class HashCodeBuilder implements Builder<Integer>
> {
> && (useTransients ||
> !Modifier.isTransient(field.getModifiers()))
> && !Modifier.isStatic(field.getModifiers())
> && !field.isAnnotationPresent(HashCodeExclude.class)) {
> - try {
> - final Object fieldValue = field.get(object);
> - builder.append(fieldValue);
> - } catch (final IllegalAccessException e) {
> - // this can't happen. Would get a Security exception
> instead
> - // throw a runtime exception in case the impossible
> happens.
> - throw new InternalError("Unexpected
> IllegalAccessException");
> - }
> + builder.append(Reflection.getUnchecked(field, object));
> }
> }
> } finally {
> diff --git a/src/main/java/org/apache/commons/lang3/builder/Reflection.java
> b/src/main/java/org/apache/commons/lang3/builder/Reflection.java
> new file mode 100644
> index 000000000..119bfe9b2
> --- /dev/null
> +++ b/src/main/java/org/apache/commons/lang3/builder/Reflection.java
> @@ -0,0 +1,44 @@
> +/*
> + * 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.builder;
> +
> +import java.lang.reflect.Field;
> +import java.util.Objects;
> +
> +/**
> + * Package-private reflection code.
> + */
> +class Reflection {
> +
> + /**
> + * Delegates to {@link Field#get(Object)} and rethrows {@link
> IllegalAccessException} as {@link IllegalArgumentException}.
> + *
> + * @param field The receiver of the get call.
> + * @param obj The argument of the get call.
> + * @return The result of the get call.
> + * @throws IllegalArgumentException Thrown after catching {@link
> IllegalAccessException}.
> + */
> + static Object getUnchecked(final Field field, final Object obj) {
> + try {
> + return Objects.requireNonNull(field, "field").get(obj);
> + } catch (IllegalAccessException e) {
> + throw new IllegalArgumentException(e);
> + }
> + }
> +
> +}
> diff --git
> a/src/main/java/org/apache/commons/lang3/builder/ReflectionDiffBuilder.java
> b/src/main/java/org/apache/commons/lang3/builder/ReflectionDiffBuilder.java
> index bacc0cb89..a5a8f9496 100644
> ---
> a/src/main/java/org/apache/commons/lang3/builder/ReflectionDiffBuilder.java
> +++
> b/src/main/java/org/apache/commons/lang3/builder/ReflectionDiffBuilder.java
> @@ -151,12 +151,11 @@ public class ReflectionDiffBuilder<T> implements
> Builder<DiffResult<T>> {
> for (final Field field : FieldUtils.getAllFields(clazz)) {
> if (accept(field)) {
> try {
> - diffBuilder.append(field.getName(),
> FieldUtils.readField(field, left, true),
> - FieldUtils.readField(field, right, true));
> - } catch (final IllegalAccessException ex) {
> + diffBuilder.append(field.getName(),
> FieldUtils.readField(field, left, true), FieldUtils.readField(field, right,
> true));
> + } catch (final IllegalAccessException e) {
> // this can't happen. Would get a Security exception
> instead
> // throw a runtime exception in case the impossible
> happens.
> - throw new InternalError("Unexpected
> IllegalAccessException: " + ex.getMessage());
> + throw new IllegalArgumentException("Unexpected
> IllegalAccessException: " + e.getMessage(), e);
> }
> }
> }
> diff --git
> a/src/main/java/org/apache/commons/lang3/builder/ReflectionToStringBuilder.java
>
> b/src/main/java/org/apache/commons/lang3/builder/ReflectionToStringBuilder.java
> index 8bb0d0e10..d6413681b 100644
> ---
> a/src/main/java/org/apache/commons/lang3/builder/ReflectionToStringBuilder.java
> +++
> b/src/main/java/org/apache/commons/lang3/builder/ReflectionToStringBuilder.java
> @@ -657,16 +657,10 @@ public class ReflectionToStringBuilder extends
> ToStringBuilder {
> for (final Field field : fields) {
> final String fieldName = field.getName();
> if (this.accept(field)) {
> - try {
> - // Warning: Field.get(Object) creates wrappers objects
> for primitive types.
> - final Object fieldValue = this.getValue(field);
> - if (!excludeNullValues || fieldValue != null) {
> - this.append(fieldName, fieldValue,
> !field.isAnnotationPresent(ToStringSummary.class));
> - }
> - } catch (final IllegalAccessException ex) {
> - // this can't happen. Would get a Security exception
> instead
> - // throw a runtime exception in case the impossible
> happens.
> - throw new InternalError("Unexpected
> IllegalAccessException: " + ex.getMessage());
> + // Warning: Field.get(Object) creates wrappers objects for
> primitive types.
> + final Object fieldValue = Reflection.getUnchecked(field,
> getObject());
> + if (!excludeNullValues || fieldValue != null) {
> + this.append(fieldName, fieldValue,
> !field.isAnnotationPresent(ToStringSummary.class));
> }
> }
> }
>
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@commons.apache.org
For additional commands, e-mail: dev-h...@commons.apache.org
