forked from fanruan/easyexcel
Jiaju Zhuang
4 years ago
committed by
GitHub
153 changed files with 2618 additions and 1234 deletions
@ -0,0 +1,13 @@
|
||||
package com.alibaba.excel.constant; |
||||
|
||||
/** |
||||
* Order constant. |
||||
* |
||||
* @author Jiaju Zhuang |
||||
*/ |
||||
public class OrderConstant { |
||||
/** |
||||
* Sorting of styles written to cells. |
||||
*/ |
||||
public static final int FILL_DATA_FORMAT = 10000; |
||||
} |
||||
@ -0,0 +1,47 @@
|
||||
package com.alibaba.excel.converters.date; |
||||
|
||||
import java.util.Date; |
||||
|
||||
import com.alibaba.excel.converters.Converter; |
||||
import com.alibaba.excel.enums.CellDataTypeEnum; |
||||
import com.alibaba.excel.metadata.CellData; |
||||
import com.alibaba.excel.metadata.GlobalConfiguration; |
||||
import com.alibaba.excel.metadata.property.ExcelContentProperty; |
||||
import com.alibaba.excel.util.WorkBookUtil; |
||||
import com.alibaba.excel.write.metadata.holder.WriteHolder; |
||||
|
||||
/** |
||||
* Date and date converter |
||||
* |
||||
* @author Jiaju Zhuang |
||||
*/ |
||||
public class DateDateConverter implements Converter<Date> { |
||||
@Override |
||||
public Class<Date> supportJavaTypeKey() { |
||||
return Date.class; |
||||
} |
||||
|
||||
@Override |
||||
public CellDataTypeEnum supportExcelTypeKey() { |
||||
return CellDataTypeEnum.DATE; |
||||
} |
||||
|
||||
@Override |
||||
public Date convertToJavaData(CellData<?> cellData, ExcelContentProperty contentProperty, |
||||
GlobalConfiguration globalConfiguration) { |
||||
return cellData.getDateValue(); |
||||
} |
||||
|
||||
@Override |
||||
public CellData<?> convertToExcelData(Date value, ExcelContentProperty contentProperty, |
||||
WriteHolder currentWriteHolder) throws Exception { |
||||
CellData<?> cellData = new CellData<>(value); |
||||
if (contentProperty == null || contentProperty.getDateTimeFormatProperty() == null |
||||
|| contentProperty.getDateTimeFormatProperty().getFormat() == null) { |
||||
return cellData; |
||||
} |
||||
WorkBookUtil.fillDataFormat(cellData, currentWriteHolder, |
||||
contentProperty.getDateTimeFormatProperty().getFormat()); |
||||
return cellData; |
||||
} |
||||
} |
||||
@ -1,22 +0,0 @@
|
||||
package com.alibaba.excel.util; |
||||
|
||||
import java.util.Collection; |
||||
import java.util.Map; |
||||
|
||||
/** |
||||
* Collection utils |
||||
* |
||||
* @author jipengfei |
||||
*/ |
||||
public class CollectionUtils { |
||||
|
||||
private CollectionUtils() {} |
||||
|
||||
public static boolean isEmpty(Collection<?> collection) { |
||||
return (collection == null || collection.isEmpty()); |
||||
} |
||||
|
||||
public static boolean isEmpty(Map<?, ?> map) { |
||||
return (map == null || map.isEmpty()); |
||||
} |
||||
} |
||||
@ -0,0 +1,145 @@
|
||||
package com.alibaba.excel.util; |
||||
|
||||
import java.lang.reflect.Field; |
||||
import java.lang.reflect.Modifier; |
||||
|
||||
|
||||
/** |
||||
* Field utils |
||||
* |
||||
* @author Jiaju Zhuang |
||||
**/ |
||||
public class FieldUtils { |
||||
|
||||
private static final int START_RESOLVE_FIELD_LENGTH = 2; |
||||
|
||||
/** |
||||
* Parsing the name matching cglib。 |
||||
* <ul> |
||||
* <ul>null -> null</ul> |
||||
* <ul>string1 -> string1</ul> |
||||
* <ul>String2 -> string2</ul> |
||||
* <ul>sTring3 -> STring3</ul> |
||||
* <ul>STring4 -> STring4</ul> |
||||
* <ul>STRING5 -> STRING5</ul> |
||||
* <ul>STRing6 -> STRing6</ul> |
||||
* </ul> |
||||
* |
||||
* @param field field |
||||
* @return field name. |
||||
*/ |
||||
public static String resolveCglibFieldName(Field field) { |
||||
if (field == null) { |
||||
return null; |
||||
} |
||||
String fieldName = field.getName(); |
||||
if (StringUtils.isBlank(fieldName) || fieldName.length() < START_RESOLVE_FIELD_LENGTH) { |
||||
return fieldName; |
||||
} |
||||
char firstChar = fieldName.charAt(0); |
||||
char secondChar = fieldName.charAt(1); |
||||
if (Character.isUpperCase(firstChar) == Character.isUpperCase(secondChar)) { |
||||
return fieldName; |
||||
} |
||||
if (Character.isUpperCase(firstChar)) { |
||||
return buildFieldName(Character.toLowerCase(firstChar), fieldName); |
||||
} |
||||
return buildFieldName(Character.toUpperCase(firstChar), fieldName); |
||||
} |
||||
|
||||
private static String buildFieldName(char firstChar, String fieldName) { |
||||
return firstChar + fieldName.substring(1); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Gets an accessible {@link Field} by name respecting scope. Superclasses/interfaces will be considered. |
||||
* |
||||
* @param cls |
||||
* the {@link Class} to reflect, must not be {@code null} |
||||
* @param fieldName |
||||
* the field name to obtain |
||||
* @return the Field object |
||||
* @throws IllegalArgumentException |
||||
* if the class is {@code null}, or the field name is blank or empty |
||||
*/ |
||||
public static Field getField(final Class<?> cls, final String fieldName) { |
||||
final Field field = getField(cls, fieldName, false); |
||||
MemberUtils.setAccessibleWorkaround(field); |
||||
return field; |
||||
} |
||||
|
||||
|
||||
|
||||
/** |
||||
* Gets an accessible {@link Field} by name, breaking scope if requested. Superclasses/interfaces will be |
||||
* considered. |
||||
* |
||||
* @param cls |
||||
* the {@link Class} to reflect, must not be {@code null} |
||||
* @param fieldName |
||||
* the field name to obtain |
||||
* @param forceAccess |
||||
* whether to break scope restrictions using the |
||||
* {@link java.lang.reflect.AccessibleObject#setAccessible(boolean)} method. {@code false} will only |
||||
* match {@code public} fields. |
||||
* @return the Field object |
||||
* @throws NullPointerException if the class is {@code null} |
||||
* @throws IllegalArgumentException if the field name is blank or empty or is matched at multiple places |
||||
* in the inheritance hierarchy |
||||
*/ |
||||
public static Field getField(final Class<?> cls, final String fieldName, final boolean forceAccess) { |
||||
Validate.isTrue(cls != null, "The class must not be null"); |
||||
Validate.isTrue(StringUtils.isNotBlank(fieldName), "The field name must not be blank/empty"); |
||||
// FIXME is this workaround still needed? lang requires Java 6
|
||||
// Sun Java 1.3 has a bugged implementation of getField hence we write the
|
||||
// code ourselves
|
||||
|
||||
// getField() will return the Field object with the declaring class
|
||||
// set correctly to the class that declares the field. Thus requesting the
|
||||
// field on a subclass will return the field from the superclass.
|
||||
//
|
||||
// priority order for lookup:
|
||||
// searchclass private/protected/package/public
|
||||
// superclass protected/package/public
|
||||
// private/different package blocks access to further superclasses
|
||||
// implementedinterface public
|
||||
|
||||
// check up the superclass hierarchy
|
||||
for (Class<?> acls = cls; acls != null; acls = acls.getSuperclass()) { |
||||
try { |
||||
final Field field = acls.getDeclaredField(fieldName); |
||||
// getDeclaredField checks for non-public scopes as well
|
||||
// and it returns accurate results
|
||||
if (!Modifier.isPublic(field.getModifiers())) { |
||||
if (forceAccess) { |
||||
field.setAccessible(true); |
||||
} else { |
||||
continue; |
||||
} |
||||
} |
||||
return field; |
||||
} catch (final NoSuchFieldException ex) { // NOPMD
|
||||
// ignore
|
||||
} |
||||
} |
||||
// check the public interface case. This must be manually searched for
|
||||
// incase there is a public supersuperclass field hidden by a private/package
|
||||
// superclass field.
|
||||
Field match = null; |
||||
for (final Class<?> class1 : ClassUtils.getAllInterfaces(cls)) { |
||||
try { |
||||
final Field test = class1.getField(fieldName); |
||||
Validate.isTrue(match == null, "Reference to field %s is ambiguous relative to %s" |
||||
+ "; a matching field exists on two or more implemented interfaces.", fieldName, cls); |
||||
match = test; |
||||
} catch (final NoSuchFieldException ex) { // NOPMD
|
||||
// ignore
|
||||
} |
||||
} |
||||
return match; |
||||
} |
||||
|
||||
|
||||
|
||||
} |
||||
@ -0,0 +1,39 @@
|
||||
package com.alibaba.excel.util; |
||||
|
||||
import java.util.ArrayList; |
||||
import java.util.List; |
||||
|
||||
/** |
||||
* Int utils |
||||
* |
||||
* @author Jiaju Zhuang |
||||
**/ |
||||
public class IntUtils { |
||||
private IntUtils() {} |
||||
|
||||
|
||||
/** |
||||
* The largest power of two that can be represented as an {@code int}. |
||||
* |
||||
* @since 10.0 |
||||
*/ |
||||
public static final int MAX_POWER_OF_TWO = 1 << (Integer.SIZE - 2); |
||||
|
||||
/** |
||||
* Returns the {@code int} nearest in value to {@code value}. |
||||
* |
||||
* @param value any {@code long} value |
||||
* @return the same value cast to {@code int} if it is in the range of the {@code int} type, |
||||
* {@link Integer#MAX_VALUE} if it is too large, or {@link Integer#MIN_VALUE} if it is too |
||||
* small |
||||
*/ |
||||
public static int saturatedCast(long value) { |
||||
if (value > Integer.MAX_VALUE) { |
||||
return Integer.MAX_VALUE; |
||||
} |
||||
if (value < Integer.MIN_VALUE) { |
||||
return Integer.MIN_VALUE; |
||||
} |
||||
return (int) value; |
||||
} |
||||
} |
||||
@ -0,0 +1,121 @@
|
||||
package com.alibaba.excel.util; |
||||
|
||||
import java.util.ArrayList; |
||||
import java.util.Collection; |
||||
import java.util.Iterator; |
||||
import java.util.List; |
||||
|
||||
import lombok.NonNull; |
||||
import org.apache.commons.compress.utils.Iterators; |
||||
|
||||
/** |
||||
* List utils |
||||
* |
||||
* @author Jiaju Zhuang |
||||
**/ |
||||
public class ListUtils { |
||||
private ListUtils() {} |
||||
|
||||
/** |
||||
* Creates a <i>mutable</i>, empty {@code ArrayList} instance (for Java 6 and earlier). |
||||
* |
||||
* <p><b>Note for Java 7 and later:</b> this method is now unnecessary and should be treated as |
||||
* deprecated. Instead, use the {@code ArrayList} {@linkplain ArrayList#ArrayList() constructor} |
||||
* directly, taking advantage of the new <a href="http://goo.gl/iz2Wi">"diamond" syntax</a>. |
||||
*/ |
||||
public static <E> ArrayList<E> newArrayList() { |
||||
return new ArrayList<>(); |
||||
} |
||||
|
||||
/** |
||||
* Creates a <i>mutable</i> {@code ArrayList} instance containing the given elements; a very thin |
||||
* shortcut for creating an empty list and then calling {@link Iterators#addAll}. |
||||
* |
||||
*/ |
||||
public static <E> ArrayList<E> newArrayList(Iterator<? extends E> elements) { |
||||
ArrayList<E> list = newArrayList(); |
||||
Iterators.addAll(list, elements); |
||||
return list; |
||||
} |
||||
|
||||
/** |
||||
* Creates a <i>mutable</i> {@code ArrayList} instance containing the given elements; |
||||
* |
||||
* |
||||
* <p><b>Note for Java 7 and later:</b> if {@code elements} is a {@link Collection}, you don't |
||||
* need this method. Use the {@code ArrayList} {@linkplain ArrayList#ArrayList(Collection) |
||||
* constructor} directly, taking advantage of the new <a href="http://goo.gl/iz2Wi">"diamond" |
||||
* syntax</a>. |
||||
*/ |
||||
public static <E> ArrayList<E> newArrayList(Iterable<? extends E> elements) { |
||||
checkNotNull(elements); // for GWT
|
||||
// Let ArrayList's sizing logic work, if possible
|
||||
return (elements instanceof Collection) |
||||
? new ArrayList<>((Collection<? extends E>)elements) |
||||
: newArrayList(elements.iterator()); |
||||
} |
||||
|
||||
/** |
||||
* Creates an {@code ArrayList} instance backed by an array with the specified initial size; |
||||
* simply delegates to {@link ArrayList#ArrayList(int)}. |
||||
* |
||||
* <p><b>Note for Java 7 and later:</b> this method is now unnecessary and should be treated as |
||||
* deprecated. Instead, use {@code new }{@link ArrayList#ArrayList(int) ArrayList}{@code <>(int)} |
||||
* directly, taking advantage of the new <a href="http://goo.gl/iz2Wi">"diamond" syntax</a>. |
||||
* (Unlike here, there is no risk of overload ambiguity, since the {@code ArrayList} constructors |
||||
* very wisely did not accept varargs.) |
||||
* |
||||
* @param initialArraySize the exact size of the initial backing array for the returned array list |
||||
* ({@code ArrayList} documentation calls this value the "capacity") |
||||
* @return a new, empty {@code ArrayList} which is guaranteed not to resize itself unless its size |
||||
* reaches {@code initialArraySize + 1} |
||||
* @throws IllegalArgumentException if {@code initialArraySize} is negative |
||||
*/ |
||||
public static <E> ArrayList<E> newArrayListWithCapacity(int initialArraySize) { |
||||
checkNonnegative(initialArraySize, "initialArraySize"); |
||||
return new ArrayList<>(initialArraySize); |
||||
} |
||||
|
||||
/** |
||||
* Creates an {@code ArrayList} instance to hold {@code estimatedSize} elements, <i>plus</i> an |
||||
* unspecified amount of padding; you almost certainly mean to call {@link |
||||
* #newArrayListWithCapacity} (see that method for further advice on usage). |
||||
* |
||||
* <p><b>Note:</b> This method will soon be deprecated. Even in the rare case that you do want |
||||
* some amount of padding, it's best if you choose your desired amount explicitly. |
||||
* |
||||
* @param estimatedSize an estimate of the eventual {@link List#size()} of the new list |
||||
* @return a new, empty {@code ArrayList}, sized appropriately to hold the estimated number of |
||||
* elements |
||||
* @throws IllegalArgumentException if {@code estimatedSize} is negative |
||||
*/ |
||||
public static <E> ArrayList<E> newArrayListWithExpectedSize(int estimatedSize) { |
||||
return new ArrayList<>(computeArrayListCapacity(estimatedSize)); |
||||
} |
||||
|
||||
static int computeArrayListCapacity(int arraySize) { |
||||
checkNonnegative(arraySize, "arraySize"); |
||||
return IntUtils.saturatedCast(5L + arraySize + (arraySize / 10)); |
||||
} |
||||
|
||||
static int checkNonnegative(int value, String name) { |
||||
if (value < 0) { |
||||
throw new IllegalArgumentException(name + " cannot be negative but was: " + value); |
||||
} |
||||
return value; |
||||
} |
||||
|
||||
/** |
||||
* Ensures that an object reference passed as a parameter to the calling method is not null. |
||||
* |
||||
* @param reference an object reference |
||||
* @return the non-null reference that was validated |
||||
* @throws NullPointerException if {@code reference} is null |
||||
*/ |
||||
public static <T extends @NonNull Object> T checkNotNull(T reference) { |
||||
if (reference == null) { |
||||
throw new NullPointerException(); |
||||
} |
||||
return reference; |
||||
} |
||||
} |
||||
@ -0,0 +1,63 @@
|
||||
package com.alibaba.excel.util; |
||||
|
||||
import java.util.ArrayList; |
||||
import java.util.HashMap; |
||||
import java.util.List; |
||||
import java.util.Map; |
||||
|
||||
/** |
||||
* Map utils |
||||
* |
||||
* @author Jiaju Zhuang |
||||
**/ |
||||
public class MapUtils { |
||||
private MapUtils() {} |
||||
/** |
||||
* Creates a <i>mutable</i>, empty {@code HashMap} instance. |
||||
* |
||||
* <p><b>Note:</b> if mutability is not required, use {@link ImmutableMap#of()} instead. |
||||
* |
||||
* <p><b>Note:</b> if {@code K} is an {@code enum} type, use {@link #newEnumMap} instead. |
||||
* |
||||
* <p><b>Note for Java 7 and later:</b> this method is now unnecessary and should be treated as |
||||
* deprecated. Instead, use the {@code HashMap} constructor directly, taking advantage of the new |
||||
* <a href="http://goo.gl/iz2Wi">"diamond" syntax</a>. |
||||
* |
||||
* @return a new, empty {@code HashMap} |
||||
*/ |
||||
public static <K, V> HashMap<K, V> newHashMap() { |
||||
return new HashMap<>(); |
||||
} |
||||
|
||||
/** |
||||
* Creates a {@code HashMap} instance, with a high enough "initial capacity" that it <i>should</i> |
||||
* hold {@code expectedSize} elements without growth. This behavior cannot be broadly guaranteed, |
||||
* but it is observed to be true for OpenJDK 1.7. It also can't be guaranteed that the method |
||||
* isn't inadvertently <i>oversizing</i> the returned map. |
||||
* |
||||
* @param expectedSize the number of entries you expect to add to the returned map |
||||
* @return a new, empty {@code HashMap} with enough capacity to hold {@code expectedSize} entries |
||||
* without resizing |
||||
* @throws IllegalArgumentException if {@code expectedSize} is negative |
||||
*/ |
||||
public static <K, V> HashMap<K, V> newHashMapWithExpectedSize(int expectedSize) { |
||||
return new HashMap<>(capacity(expectedSize)); |
||||
} |
||||
|
||||
/** |
||||
* Returns a capacity that is sufficient to keep the map from being resized as long as it grows no |
||||
* larger than expectedSize and the load factor is ≥ its default (0.75). |
||||
*/ |
||||
static int capacity(int expectedSize) { |
||||
if (expectedSize < 3) { |
||||
return expectedSize + 1; |
||||
} |
||||
if (expectedSize < IntUtils.MAX_POWER_OF_TWO) { |
||||
// This is the calculation used in JDK8 to resize when a putAll
|
||||
// happens; it seems to be the most conservative calculation we
|
||||
// can make. 0.75 is the default load factor.
|
||||
return (int) ((float) expectedSize / 0.75F + 1.0F); |
||||
} |
||||
return Integer.MAX_VALUE; |
||||
} |
||||
} |
||||
@ -0,0 +1,54 @@
|
||||
package com.alibaba.excel.util; |
||||
|
||||
import java.lang.reflect.AccessibleObject; |
||||
import java.lang.reflect.Member; |
||||
import java.lang.reflect.Modifier; |
||||
|
||||
/** |
||||
* Member utils. |
||||
* |
||||
* @author Jiaju Zhuang |
||||
*/ |
||||
public class MemberUtils { |
||||
|
||||
private static final int ACCESS_TEST = Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE; |
||||
|
||||
|
||||
/** |
||||
* XXX Default access superclass workaround. |
||||
* |
||||
* When a {@code public} class has a default access superclass with {@code public} members, |
||||
* these members are accessible. Calling them from compiled code works fine. |
||||
* Unfortunately, on some JVMs, using reflection to invoke these members |
||||
* seems to (wrongly) prevent access even when the modifier is {@code public}. |
||||
* Calling {@code setAccessible(true)} solves the problem but will only work from |
||||
* sufficiently privileged code. Better workarounds would be gratefully |
||||
* accepted. |
||||
* @param o the AccessibleObject to set as accessible |
||||
* @return a boolean indicating whether the accessibility of the object was set to true. |
||||
*/ |
||||
static boolean setAccessibleWorkaround(final AccessibleObject o) { |
||||
if (o == null || o.isAccessible()) { |
||||
return false; |
||||
} |
||||
final Member m = (Member) o; |
||||
if (!o.isAccessible() && Modifier.isPublic(m.getModifiers()) && isPackageAccess(m.getDeclaringClass().getModifiers())) { |
||||
try { |
||||
o.setAccessible(true); |
||||
return true; |
||||
} catch (final SecurityException e) { // NOPMD
|
||||
// ignore in favor of subsequent IllegalAccessException
|
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/** |
||||
* Returns whether a given set of modifiers implies package access. |
||||
* @param modifiers to test |
||||
* @return {@code true} unless {@code package}/{@code protected}/{@code private} modifier detected |
||||
*/ |
||||
static boolean isPackageAccess(final int modifiers) { |
||||
return (modifiers & ACCESS_TEST) == 0; |
||||
} |
||||
} |
||||
@ -0,0 +1,151 @@
|
||||
package com.alibaba.excel.util; |
||||
|
||||
import java.util.Objects; |
||||
|
||||
/** |
||||
* Validate |
||||
* |
||||
* @author Jiaju Zhuang |
||||
*/ |
||||
public class Validate { |
||||
|
||||
private static final String DEFAULT_IS_TRUE_EX_MESSAGE = "The validated expression is false"; |
||||
private static final String DEFAULT_IS_NULL_EX_MESSAGE = "The validated object is null"; |
||||
|
||||
/** |
||||
* <p>Validate that the argument condition is {@code true}; otherwise |
||||
* throwing an exception with the specified message. This method is useful when |
||||
* validating according to an arbitrary boolean expression, such as validating a |
||||
* primitive number or using your own custom validation expression.</p> |
||||
* |
||||
* <pre>Validate.isTrue(i > 0.0, "The value must be greater than zero: %d", i);</pre> |
||||
* |
||||
* <p>For performance reasons, the long value is passed as a separate parameter and |
||||
* appended to the exception message only in the case of an error.</p> |
||||
* |
||||
* @param expression the boolean expression to check |
||||
* @param message the {@link String#format(String, Object...)} exception message if invalid, not null |
||||
* @param value the value to append to the message when invalid |
||||
* @throws IllegalArgumentException if expression is {@code false} |
||||
* @see #isTrue(boolean) |
||||
* @see #isTrue(boolean, String, double) |
||||
* @see #isTrue(boolean, String, Object...) |
||||
*/ |
||||
public static void isTrue(final boolean expression, final String message, final long value) { |
||||
if (!expression) { |
||||
throw new IllegalArgumentException(String.format(message, Long.valueOf(value))); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* <p>Validate that the argument condition is {@code true}; otherwise |
||||
* throwing an exception with the specified message. This method is useful when |
||||
* validating according to an arbitrary boolean expression, such as validating a |
||||
* primitive number or using your own custom validation expression.</p> |
||||
* |
||||
* <pre>Validate.isTrue(d > 0.0, "The value must be greater than zero: %s", d);</pre> |
||||
* |
||||
* <p>For performance reasons, the double value is passed as a separate parameter and |
||||
* appended to the exception message only in the case of an error.</p> |
||||
* |
||||
* @param expression the boolean expression to check |
||||
* @param message the {@link String#format(String, Object...)} exception message if invalid, not null |
||||
* @param value the value to append to the message when invalid |
||||
* @throws IllegalArgumentException if expression is {@code false} |
||||
* @see #isTrue(boolean) |
||||
* @see #isTrue(boolean, String, long) |
||||
* @see #isTrue(boolean, String, Object...) |
||||
*/ |
||||
public static void isTrue(final boolean expression, final String message, final double value) { |
||||
if (!expression) { |
||||
throw new IllegalArgumentException(String.format(message, Double.valueOf(value))); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* <p>Validate that the argument condition is {@code true}; otherwise |
||||
* throwing an exception with the specified message. This method is useful when |
||||
* validating according to an arbitrary boolean expression, such as validating a |
||||
* primitive number or using your own custom validation expression.</p> |
||||
* |
||||
* <pre> |
||||
* Validate.isTrue(i >= min && i <= max, "The value must be between %d and %d", min, max); |
||||
* Validate.isTrue(myObject.isOk(), "The object is not okay");</pre> |
||||
* |
||||
* @param expression the boolean expression to check |
||||
* @param message the {@link String#format(String, Object...)} exception message if invalid, not null |
||||
* @param values the optional values for the formatted exception message, null array not recommended |
||||
* @throws IllegalArgumentException if expression is {@code false} |
||||
* @see #isTrue(boolean) |
||||
* @see #isTrue(boolean, String, long) |
||||
* @see #isTrue(boolean, String, double) |
||||
*/ |
||||
public static void isTrue(final boolean expression, final String message, final Object... values) { |
||||
if (!expression) { |
||||
throw new IllegalArgumentException(String.format(message, values)); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* <p>Validate that the argument condition is {@code true}; otherwise |
||||
* throwing an exception. This method is useful when validating according |
||||
* to an arbitrary boolean expression, such as validating a |
||||
* primitive number or using your own custom validation expression.</p> |
||||
* |
||||
* <pre> |
||||
* Validate.isTrue(i > 0); |
||||
* Validate.isTrue(myObject.isOk());</pre> |
||||
* |
||||
* <p>The message of the exception is "The validated expression is |
||||
* false".</p> |
||||
* |
||||
* @param expression the boolean expression to check |
||||
* @throws IllegalArgumentException if expression is {@code false} |
||||
* @see #isTrue(boolean, String, long) |
||||
* @see #isTrue(boolean, String, double) |
||||
* @see #isTrue(boolean, String, Object...) |
||||
*/ |
||||
public static void isTrue(final boolean expression) { |
||||
if (!expression) { |
||||
throw new IllegalArgumentException(DEFAULT_IS_TRUE_EX_MESSAGE); |
||||
} |
||||
} |
||||
|
||||
|
||||
/** |
||||
* <p>Validate that the specified argument is not {@code null}; |
||||
* otherwise throwing an exception. |
||||
* |
||||
* <pre>Validate.notNull(myObject, "The object must not be null");</pre> |
||||
* |
||||
* <p>The message of the exception is "The validated object is |
||||
* null".</p> |
||||
* |
||||
* @param <T> the object type |
||||
* @param object the object to check |
||||
* @return the validated object (never {@code null} for method chaining) |
||||
* @throws NullPointerException if the object is {@code null} |
||||
* @see #notNull(Object, String, Object...) |
||||
*/ |
||||
public static <T> T notNull(final T object) { |
||||
return notNull(object, DEFAULT_IS_NULL_EX_MESSAGE); |
||||
} |
||||
|
||||
/** |
||||
* <p>Validate that the specified argument is not {@code null}; |
||||
* otherwise throwing an exception with the specified message. |
||||
* |
||||
* <pre>Validate.notNull(myObject, "The object must not be null");</pre> |
||||
* |
||||
* @param <T> the object type |
||||
* @param object the object to check |
||||
* @param message the {@link String#format(String, Object...)} exception message if invalid, not null |
||||
* @param values the optional values for the formatted exception message |
||||
* @return the validated object (never {@code null} for method chaining) |
||||
* @throws NullPointerException if the object is {@code null} |
||||
* @see #notNull(Object) |
||||
*/ |
||||
public static <T> T notNull(final T object, final String message, final Object... values) { |
||||
return Objects.requireNonNull(object, () -> String.format(message, values)); |
||||
} |
||||
} |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue