Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.google.common.base
Class Preconditions

    java.lang.Object
      com.google.common.base.Preconditions

    @GwtCompatible
    public final class Preconditions

extends Object

Simple static methods to be called at the start of your own methods to verify correct arguments and state. This allows constructs such as

         if (count <= 0) {
           throw new IllegalArgumentException("must be positive: " + count);
         }

to be replaced with the more compact

         checkArgument(count > 0, "must be positive: %s", count);

Note that the sense of the expression is inverted; with `Preconditions` you declare what you expect to be true, just as you do with an `assert` or a JUnit `assertTrue` call.

Warning: only the `"%s"` specifier is recognized as a placeholder in these messages, not the full range of `String.format(String, Object[])` specifiers.

Take care not to confuse precondition checking with other similar types of checks! Precondition exceptions -- including those provided here, but also `IndexOutOfBoundsException`, `NoSuchElementException`, `UnsupportedOperationException` and others -- are used to signal that the calling method has made an error. This tells the caller that it should not have invoked the method when it did, with the arguments it did, or perhaps ever. Postcondition or other invariant failures should not throw these types of exceptions.

See the Guava User Guide on using `Preconditions`.

Since:
  2.0 (imported from Google Collections Library)
Author:
  Kevin Bourrillion

Method Summary
`static void` | `checkArgument(boolean expression)` Ensures the truth of an expression involving one or more parameters to the calling method.
`static void` | `checkArgument(boolean expression, Object errorMessage)` Ensures the truth of an expression involving one or more parameters to the calling method.
`static void` | `checkArgument(boolean expression, String errorMessageTemplate, Object... errorMessageArgs)` Ensures the truth of an expression involving one or more parameters to the calling method.
`static int` | `checkElementIndex(int index, int size)` Ensures that `index` specifies a valid element in an array, list or string of size `size`.
`static int` | `checkElementIndex(int index, int size, String desc)` Ensures that `index` specifies a valid element in an array, list or string of size `size`.
`static
`<T> T`
` | `checkNotNull(T reference)` Ensures that an object reference passed as a parameter to the calling method is not null.
`static
`<T> T`
` | `checkNotNull(T reference, Object errorMessage)` Ensures that an object reference passed as a parameter to the calling method is not null.
`static
`<T> T`
` | `checkNotNull(T reference, String errorMessageTemplate, Object... errorMessageArgs)` Ensures that an object reference passed as a parameter to the calling method is not null.
`static int` | `checkPositionIndex(int index, int size)` Ensures that `index` specifies a valid position in an array, list or string of size `size`.
`static int` | `checkPositionIndex(int index, int size, String desc)` Ensures that `index` specifies a valid position in an array, list or string of size `size`.
`static void` | `checkPositionIndexes(int start, int end, int size)` Ensures that `start` and `end` specify a valid positions in an array, list or string of size `size`, and are in order.
`static void` | `checkState(boolean expression)` Ensures the truth of an expression involving the state of the calling instance, but not involving any parameters to the calling method.
`static void` | `checkState(boolean expression, Object errorMessage)` Ensures the truth of an expression involving the state of the calling instance, but not involving any parameters to the calling method.
`static void` | `checkState(boolean expression, String errorMessageTemplate, Object... errorMessageArgs)` Ensures the truth of an expression involving the state of the calling instance, but not involving any parameters to the calling method.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Method Detail

### checkArgument

    public static void checkArgument(boolean expression)

  Ensures the truth of an expression involving one or more parameters to the calling method.

  Parameters:
    `expression` - a boolean expression
  Throws:
    `IllegalArgumentException` - if `expression` is false

### checkArgument

    public static void checkArgument(boolean expression,
                                     @Nullable
                                     Object errorMessage)

  Ensures the truth of an expression involving one or more parameters to the calling method.

  Parameters:
    `expression` - a boolean expression
    `errorMessage` - the exception message to use if the check fails; will be converted to a string using `String.valueOf(Object)`
  Throws:
    `IllegalArgumentException` - if `expression` is false

### checkArgument

    public static void checkArgument(boolean expression,
                                     @Nullable
                                     String errorMessageTemplate,
                                     @Nullable
                                     Object... errorMessageArgs)

  Ensures the truth of an expression involving one or more parameters to the calling method.

  Parameters:
    `expression` - a boolean expression
    `errorMessageTemplate` - a template for the exception message should the check fail. The message is formed by replacing each `%s` placeholder in the template with an argument. These are matched by position - the first `%s` gets `errorMessageArgs[0]`, etc. Unmatched arguments will be appended to the formatted message in square braces. Unmatched placeholders will be left as-is.
    `errorMessageArgs` - the arguments to be substituted into the message template. Arguments are converted to strings using `String.valueOf(Object)`.
  Throws:
    `IllegalArgumentException` - if `expression` is false
    `NullPointerException` - if the check fails and either `errorMessageTemplate` or `errorMessageArgs` is null (don't let this happen)

### checkState

    public static void checkState(boolean expression)

  Ensures the truth of an expression involving the state of the calling instance, but not involving any parameters to the calling method.

  Parameters:
    `expression` - a boolean expression
  Throws:
    `IllegalStateException` - if `expression` is false

### checkState

    public static void checkState(boolean expression,
                                  @Nullable
                                  Object errorMessage)

  Ensures the truth of an expression involving the state of the calling instance, but not involving any parameters to the calling method.

  Parameters:
    `expression` - a boolean expression
    `errorMessage` - the exception message to use if the check fails; will be converted to a string using `String.valueOf(Object)`
  Throws:
    `IllegalStateException` - if `expression` is false

### checkState

    public static void checkState(boolean expression,
                                  @Nullable
                                  String errorMessageTemplate,
                                  @Nullable
                                  Object... errorMessageArgs)

  Ensures the truth of an expression involving the state of the calling instance, but not involving any parameters to the calling method.

  Parameters:
    `expression` - a boolean expression
    `errorMessageTemplate` - a template for the exception message should the check fail. The message is formed by replacing each `%s` placeholder in the template with an argument. These are matched by position - the first `%s` gets `errorMessageArgs[0]`, etc. Unmatched arguments will be appended to the formatted message in square braces. Unmatched placeholders will be left as-is.
    `errorMessageArgs` - the arguments to be substituted into the message template. Arguments are converted to strings using `String.valueOf(Object)`.
  Throws:
    `IllegalStateException` - if `expression` is false
    `NullPointerException` - if the check fails and either `errorMessageTemplate` or `errorMessageArgs` is null (don't let this happen)

### checkNotNull

    public static <T> T checkNotNull(T reference)

  Ensures that an object reference passed as a parameter to the calling method is not null.

  Parameters:
    `reference` - an object reference
  Returns:
    the non-null reference that was validated
  Throws:
    `NullPointerException` - if `reference` is null

### checkNotNull

    public static <T> T checkNotNull(T reference,
                                     @Nullable
                                     Object errorMessage)

  Ensures that an object reference passed as a parameter to the calling method is not null.

  Parameters:
    `reference` - an object reference
    `errorMessage` - the exception message to use if the check fails; will be converted to a string using `String.valueOf(Object)`
  Returns:
    the non-null reference that was validated
  Throws:
    `NullPointerException` - if `reference` is null

### checkNotNull

    public static <T> T checkNotNull(T reference,
                                     @Nullable
                                     String errorMessageTemplate,
                                     @Nullable
                                     Object... errorMessageArgs)

  Ensures that an object reference passed as a parameter to the calling method is not null.

  Parameters:
    `reference` - an object reference
    `errorMessageTemplate` - a template for the exception message should the check fail. The message is formed by replacing each `%s` placeholder in the template with an argument. These are matched by position - the first `%s` gets `errorMessageArgs[0]`, etc. Unmatched arguments will be appended to the formatted message in square braces. Unmatched placeholders will be left as-is.
    `errorMessageArgs` - the arguments to be substituted into the message template. Arguments are converted to strings using `String.valueOf(Object)`.
  Returns:
    the non-null reference that was validated
  Throws:
    `NullPointerException` - if `reference` is null

### checkElementIndex

    public static int checkElementIndex(int index,
                                        int size)

  Ensures that `index` specifies a valid element in an array, list or string of size `size`. An element index may range from zero, inclusive, to `size`, exclusive.

  Parameters:
    `index` - a user-supplied index identifying an element of an array, list or string
    `size` - the size of that array, list or string
  Returns:
    the value of `index`
  Throws:
    `IndexOutOfBoundsException` - if `index` is negative or is not less than `size`
    `IllegalArgumentException` - if `size` is negative

### checkElementIndex

    public static int checkElementIndex(int index,
                                        int size,
                                        @Nullable
                                        String desc)

  Ensures that `index` specifies a valid element in an array, list or string of size `size`. An element index may range from zero, inclusive, to `size`, exclusive.

  Parameters:
    `index` - a user-supplied index identifying an element of an array, list or string
    `size` - the size of that array, list or string
    `desc` - the text to use to describe this index in an error message
  Returns:
    the value of `index`
  Throws:
    `IndexOutOfBoundsException` - if `index` is negative or is not less than `size`
    `IllegalArgumentException` - if `size` is negative

### checkPositionIndex

    public static int checkPositionIndex(int index,
                                         int size)

  Ensures that `index` specifies a valid position in an array, list or string of size `size`. A position index may range from zero to `size`, inclusive.

  Parameters:
    `index` - a user-supplied index identifying a position in an array, list or string
    `size` - the size of that array, list or string
  Returns:
    the value of `index`
  Throws:
    `IndexOutOfBoundsException` - if `index` is negative or is greater than `size`
    `IllegalArgumentException` - if `size` is negative

### checkPositionIndex

    public static int checkPositionIndex(int index,
                                         int size,
                                         @Nullable
                                         String desc)

  Ensures that `index` specifies a valid position in an array, list or string of size `size`. A position index may range from zero to `size`, inclusive.

  Parameters:
    `index` - a user-supplied index identifying a position in an array, list or string
    `size` - the size of that array, list or string
    `desc` - the text to use to describe this index in an error message
  Returns:
    the value of `index`
  Throws:
    `IndexOutOfBoundsException` - if `index` is negative or is greater than `size`
    `IllegalArgumentException` - if `size` is negative

### checkPositionIndexes

    public static void checkPositionIndexes(int start,
                                            int end,
                                            int size)

  Ensures that `start` and `end` specify a valid positions in an array, list or string of size `size`, and are in order. A position index may range from zero to `size`, inclusive.

  Parameters:
    `start` - a user-supplied index identifying a starting position in an array, list or string
    `end` - a user-supplied index identifying a ending position in an array, list or string
    `size` - the size of that array, list or string
  Throws:
    `IndexOutOfBoundsException` - if either index is negative or is greater than `size`, or if `end` is less than `start`
    `IllegalArgumentException` - if `size` is negative

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2010-2012. All Rights Reserved.