| /* | |
| * Copyright 2014 Google Inc. | |
| * | |
| * Licensed 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 javaemul.internal; | |
| import java.util.NoSuchElementException; | |
| /** | |
| * A utility class that provides utility functions to do precondition checks inside GWT-SDK. | |
| */ | |
| // Some parts adapted from Guava | |
| public final class InternalPreconditions { | |
| private static final boolean CHECKED_MODE = System.getProperty("superdevmode").equals("on"); | |
| private static final boolean JSNI_CHECK = System.getProperty("checks.jsni").equals("ENABLED"); | |
| private static final boolean TYPE_CHECK = System.getProperty("checks.type").equals("ENABLED"); | |
| private static final boolean API_CHECK = System.getProperty("checks.api").equals("ENABLED"); | |
| private static final boolean BOUND_CHECK = System.getProperty("checks.bounds").equals("ENABLED"); | |
| public static void checkType(boolean expression) { | |
| if (TYPE_CHECK) { | |
| checkCriticalType(expression); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalType(expression); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| public static void checkCriticalType(boolean expression) { | |
| if (!expression) { | |
| throw new ClassCastException(); | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression that verifies array type. | |
| */ | |
| public static void checkArrayType(boolean expression) { | |
| if (TYPE_CHECK) { | |
| checkCriticalArrayType(expression); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalArrayType(expression); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| public static void checkCriticalArrayType(boolean expression) { | |
| if (!expression) { | |
| throw new ArrayStoreException(); | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression that verifies array type. | |
| */ | |
| public static void checkArrayType(boolean expression, Object errorMessage) { | |
| if (TYPE_CHECK) { | |
| checkCriticalArrayType(expression, errorMessage); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalArrayType(expression, errorMessage); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| public static void checkCriticalArrayType(boolean expression, Object errorMessage) { | |
| if (!expression) { | |
| throw new ArrayStoreException(String.valueOf(errorMessage)); | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving existence of an element. | |
| */ | |
| public static void checkElement(boolean expression) { | |
| if (API_CHECK) { | |
| checkCriticalElement(expression); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalElement(expression); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving existence of an element. | |
| * <p> | |
| * For cases where failing fast is pretty important and not failing early could cause bugs that | |
| * are much harder to debug. | |
| */ | |
| public static void checkCriticalElement(boolean expression) { | |
| if (!expression) { | |
| throw new NoSuchElementException(); | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving existence of an element. | |
| */ | |
| public static void checkElement(boolean expression, Object errorMessage) { | |
| if (API_CHECK) { | |
| checkCriticalElement(expression, errorMessage); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalElement(expression, errorMessage); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving existence of an element. | |
| * <p> | |
| * For cases where failing fast is pretty important and not failing early could cause bugs that | |
| * are much harder to debug. | |
| */ | |
| public static void checkCriticalElement(boolean expression, Object errorMessage) { | |
| if (!expression) { | |
| throw new NoSuchElementException(String.valueOf(errorMessage)); | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving one or more parameters to the calling method. | |
| */ | |
| public static void checkArgument(boolean expression) { | |
| if (API_CHECK) { | |
| checkCriticalArgument(expression); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalArgument(expression); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving one or more parameters to the calling method. | |
| * <p> | |
| * For cases where failing fast is pretty important and not failing early could cause bugs that | |
| * are much harder to debug. | |
| */ | |
| public static void checkCriticalArgument(boolean expression) { | |
| if (!expression) { | |
| throw new IllegalArgumentException(); | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving one or more parameters to the calling method. | |
| */ | |
| public static void checkArgument(boolean expression, Object errorMessage) { | |
| if (API_CHECK) { | |
| checkCriticalArgument(expression, errorMessage); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalArgument(expression, errorMessage); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving one or more parameters to the calling method. | |
| * <p> | |
| * For cases where failing fast is pretty important and not failing early could cause bugs that | |
| * are much harder to debug. | |
| */ | |
| public static void checkCriticalArgument(boolean expression, Object errorMessage) { | |
| if (!expression) { | |
| throw new IllegalArgumentException(String.valueOf(errorMessage)); | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving one or more parameters to the calling method. | |
| */ | |
| public static void checkArgument(boolean expression, String errorMessageTemplate, | |
| Object... errorMessageArgs) { | |
| if (API_CHECK) { | |
| checkCriticalArgument(expression, errorMessageTemplate, errorMessageArgs); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalArgument(expression, errorMessageTemplate, errorMessageArgs); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving one or more parameters to the calling method. | |
| * <p> | |
| * For cases where failing fast is pretty important and not failing early could cause bugs that | |
| * are much harder to debug. | |
| */ | |
| public static void checkCriticalArgument(boolean expression, String errorMessageTemplate, | |
| Object... errorMessageArgs) { | |
| if (!expression) { | |
| throw new IllegalArgumentException(format(errorMessageTemplate, errorMessageArgs)); | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving the state of the calling instance, but not | |
| * involving any parameters to the calling method. | |
| * | |
| * @param expression a boolean expression | |
| * @throws IllegalStateException if {@code expression} is false | |
| */ | |
| public static void checkState(boolean expression) { | |
| if (API_CHECK) { | |
| checkCritcalState(expression); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCritcalState(expression); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving the state of the calling instance, but not | |
| * involving any parameters to the calling method. | |
| * <p> | |
| * For cases where failing fast is pretty important and not failing early could cause bugs that | |
| * are much harder to debug. | |
| */ | |
| public static void checkCritcalState(boolean expression) { | |
| if (!expression) { | |
| throw new IllegalStateException(); | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving the state of the calling instance, but not | |
| * involving any parameters to the calling method. | |
| */ | |
| public static void checkState(boolean expression, Object errorMessage) { | |
| if (API_CHECK) { | |
| checkCriticalState(expression, errorMessage); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalState(expression, errorMessage); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| /** | |
| * Ensures the truth of an expression involving the state of the calling instance, but not | |
| * involving any parameters to the calling method. | |
| */ | |
| public static void checkCriticalState(boolean expression, Object errorMessage) { | |
| if (!expression) { | |
| throw new IllegalStateException(String.valueOf(errorMessage)); | |
| } | |
| } | |
| /** | |
| * Ensures that an object reference passed as a parameter to the calling method is not null. | |
| */ | |
| public static <T> T checkNotNull(T reference) { | |
| if (API_CHECK) { | |
| checkCriticalNotNull(reference); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalNotNull(reference); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| return reference; | |
| } | |
| public static <T> T checkCriticalNotNull(T reference) { | |
| if (reference == null) { | |
| throw new NullPointerException(); | |
| } | |
| return reference; | |
| } | |
| /** | |
| * Ensures that an object reference passed as a parameter to the calling method is not null. | |
| */ | |
| public static void checkNotNull(Object reference, Object errorMessage) { | |
| if (API_CHECK) { | |
| checkCriticalNotNull(reference, errorMessage); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalNotNull(reference, errorMessage); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| public static void checkCriticalNotNull(Object reference, Object errorMessage) { | |
| if (reference == null) { | |
| throw new NullPointerException(String.valueOf(errorMessage)); | |
| } | |
| } | |
| /** | |
| * Ensures that {@code size} specifies a valid array size (i.e. non-negative). | |
| */ | |
| public static void checkArraySize(int size) { | |
| if (API_CHECK) { | |
| checkCriticalArraySize(size); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalArraySize(size); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| public static void checkCriticalArraySize(int size) { | |
| if (size < 0) { | |
| throw new NegativeArraySizeException("Negative array size: " + size); | |
| } | |
| } | |
| /** | |
| * Ensures that {@code index} specifies a valid <i>element</i> in an array, list or string of size | |
| * {@code size}. An element index may range from zero, inclusive, to {@code size}, exclusive. | |
| */ | |
| public static void checkElementIndex(int index, int size) { | |
| if (BOUND_CHECK) { | |
| checkCriticalElementIndex(index, size); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalElementIndex(index, size); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| public static void checkCriticalElementIndex(int index, int size) { | |
| if (index < 0 || index >= size) { | |
| throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); | |
| } | |
| } | |
| /** | |
| * Ensures that {@code index} specifies a valid <i>position</i> in an array, list or string of | |
| * size {@code size}. A position index may range from zero to {@code size}, inclusive. | |
| */ | |
| public static void checkPositionIndex(int index, int size) { | |
| if (BOUND_CHECK) { | |
| checkCriticalPositionIndex(index, size); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalPositionIndex(index, size); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| public static void checkCriticalPositionIndex(int index, int size) { | |
| if (index < 0 || index > size) { | |
| throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); | |
| } | |
| } | |
| /** | |
| * Ensures that {@code start} and {@code end} specify a valid <i>positions</i> in an array, list | |
| * or string of size {@code size}, and are in order. A position index may range from zero to | |
| * {@code size}, inclusive. | |
| */ | |
| public static void checkPositionIndexes(int start, int end, int size) { | |
| if (BOUND_CHECK) { | |
| checkCriticalPositionIndexes(start, end, size); | |
| } else if (CHECKED_MODE) { | |
| try { | |
| checkCriticalPositionIndexes(start, end, size); | |
| } catch (Exception e) { | |
| throw new AssertionError(e); | |
| } | |
| } | |
| } | |
| /** | |
| * Ensures that {@code start} and {@code end} specify a valid <i>positions</i> in an array, list | |
| * or string of size {@code size}, and are in order. A position index may range from zero to | |
| * {@code size}, inclusive. | |
| */ | |
| public static void checkCriticalPositionIndexes(int start, int end, int size) { | |
| if (start < 0) { | |
| throw new IndexOutOfBoundsException("fromIndex: " + start + " < 0"); | |
| } | |
| if (end > size) { | |
| throw new IndexOutOfBoundsException("toIndex: " + end + " > size " + size); | |
| } | |
| if (start > end) { | |
| throw new IllegalArgumentException("fromIndex: " + start + " > toIndex: " + end); | |
| } | |
| } | |
| /** | |
| * Checks that bounds are correct. | |
| * | |
| * @throw StringIndexOutOfBoundsException if the range is not legal | |
| */ | |
| public static void checkStringBounds(int start, int end, int size) { | |
| if (start < 0) { | |
| throw new StringIndexOutOfBoundsException("fromIndex: " + start + " < 0"); | |
| } | |
| if (end > size) { | |
| throw new StringIndexOutOfBoundsException("toIndex: " + end + " > size " + size); | |
| } | |
| if (end < start) { | |
| throw new StringIndexOutOfBoundsException("fromIndex: " + start + " > toIndex: " + end); | |
| } | |
| } | |
| /** | |
| * Substitutes each {@code %s} in {@code template} with an argument. These are matched by | |
| * position: the first {@code %s} gets {@code args[0]}, etc. If there are more arguments than | |
| * placeholders, the unmatched arguments will be appended to the end of the formatted message in | |
| * square braces. | |
| */ | |
| private static String format(String template, Object... args) { | |
| template = String.valueOf(template); // null -> "null" | |
| // start substituting the arguments into the '%s' placeholders | |
| StringBuilder builder = new StringBuilder(template.length() + 16 * args.length); | |
| int templateStart = 0; | |
| int i = 0; | |
| while (i < args.length) { | |
| int placeholderStart = template.indexOf("%s", templateStart); | |
| if (placeholderStart == -1) { | |
| break; | |
| } | |
| builder.append(template.substring(templateStart, placeholderStart)); | |
| builder.append(args[i++]); | |
| templateStart = placeholderStart + 2; | |
| } | |
| builder.append(template.substring(templateStart)); | |
| // if we run out of placeholders, append the extra args in square braces | |
| if (i < args.length) { | |
| builder.append(" ["); | |
| builder.append(args[i++]); | |
| while (i < args.length) { | |
| builder.append(", "); | |
| builder.append(args[i++]); | |
| } | |
| builder.append(']'); | |
| } | |
| return builder.toString(); | |
| } | |
| // Hides the constructor for this static utility class. | |
| private InternalPreconditions() { } | |
| } |