| /* GENERATED SOURCE. DO NOT MODIFY. */ |
| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * 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 com.android.org.conscrypt; |
| |
| /** |
| * Static convenience methods that help a method or constructor check whether it was invoked |
| * correctly (that is, whether its <i>preconditions</i> were met). |
| */ |
| final class Preconditions { |
| private Preconditions() {} |
| |
| /** |
| * Ensures that an object reference passed as a parameter to the calling method is not null. |
| * |
| * @param reference an object reference |
| * @param errorMessage the exception message to use if the check fails. |
| * @return the non-null reference that was validated |
| * @throws NullPointerException if {@code reference} is null |
| */ |
| static <T> T checkNotNull(T reference, String errorMessage) { |
| if (reference == null) { |
| throw new NullPointerException(errorMessage); |
| } |
| return reference; |
| } |
| |
| /** |
| * Ensures the truth of an expression involving one or more parameters to the calling method. |
| * |
| * @param condition to condition to be tested |
| * @param errorMessage the exception message to use if the check fails. |
| * @throws IllegalArgumentException if the condition is {@code false} |
| */ |
| static void checkArgument(boolean condition, String errorMessage) { |
| if (!condition) { |
| throw new IllegalArgumentException(errorMessage); |
| } |
| } |
| |
| /** |
| * Ensures the truth of an expression involving one or more parameters to the calling method. |
| * |
| * @param condition to condition to be tested |
| * @param errorMessageTemplate the format string to be passed to {@link String#format(String, |
| * Object...)} |
| * @param arg the format argument to be passed to {@link String#format(String, Object...)} |
| * @throws IllegalArgumentException if the condition is {@code false} |
| */ |
| static void checkArgument(boolean condition, String errorMessageTemplate, Object arg) { |
| if (!condition) { |
| throw new IllegalArgumentException(String.format(errorMessageTemplate, arg)); |
| } |
| } |
| |
| /** |
| * 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. |
| * |
| * @param start a user-supplied index identifying a starting position in an array, list or string |
| * @param end a user-supplied index identifying a ending position in an array, list or string |
| * @param size the size of that array, list or string |
| * @throws IndexOutOfBoundsException if either index is negative or is greater than {@code size}, |
| * or if {@code end} is less than {@code start} |
| * @throws IllegalArgumentException if {@code size} is negative |
| */ |
| static void checkPositionIndexes(int start, int end, int size) { |
| // Carefully optimized for execution by hotspot (explanatory comment above) |
| if (start < 0 || end < start || end > size) { |
| throw new IndexOutOfBoundsException(badPositionIndexes(start, end, size)); |
| } |
| } |
| |
| private static String badPositionIndexes(int start, int end, int size) { |
| if (start < 0 || start > size) { |
| return badPositionIndex(start, size, "start index"); |
| } |
| if (end < 0 || end > size) { |
| return badPositionIndex(end, size, "end index"); |
| } |
| // end < start |
| return String.format("end index (%s) must not be less than start index (%s)", end, start); |
| } |
| |
| private static String badPositionIndex(int index, int size, String desc) { |
| if (index < 0) { |
| return String.format("%s (%s) must not be negative", desc, index); |
| } else if (size < 0) { |
| throw new IllegalArgumentException("negative size: " + size); |
| } else { // index > size |
| return String.format("%s (%s) must not be greater than size (%s)", desc, index, size); |
| } |
| } |
| } |