ExpressionTools (EclipseLink 2.5.1, build 'v20130918-f2b9fc5' API Reference)

java.lang.Object
- org.eclipse.persistence.jpa.jpql.ExpressionTools

```
public final class ExpressionTools
extends java.lang.Object
```
A utility class containing various methods related to the Hermes parser.
Provisional API: This interface is part of an interim API that is still under development and expected to change significantly before reaching stability. It is available at this early stage to solicit feedback from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken (repeatedly) as the API evolves.

Version:

2.5

Author:

Pascal Filion

Since:

2.3

Field Summary

Fields
Modifier and Type	Field and Description
`static java.util.regex.Pattern`	`DOUBLE_REGEXP` The `Pattern` representing the regular expression of a numerical value as a double.
`static java.lang.Object[]`	`EMPTY_ARRAY` The constant of an empty array.
`static java.lang.String`	`EMPTY_STRING` The constant for an empty string.
`static java.lang.String[]`	`EMPTY_STRING_ARRAY` The constant of an empty String array.
`static java.util.regex.Pattern`	`FLOAT_REGEXP` The `Pattern` representing the regular expression of a numerical value as a float.
`static java.util.regex.Pattern`	`INTEGER_REGEXP` The `Pattern` representing the regular expression of a numerical value as an integer.
`static java.util.regex.Pattern`	`LONG_REGEXP` The `Pattern` representing the regular expression of a numerical value as a long.

Method Summary

Methods
Modifier and Type	Method and Description
`static java.lang.String`	`escape(java.lang.CharSequence value, int[] position)` Converts the escape characters contained in the given `CharSequence` to their literal representation.
`static boolean`	`isFunctionExpression(WordParser wordParser, java.lang.String identifier)` Determines whether the JPQL fragment is an expression of the form `<IDENTIFIER>(`.
`static boolean`	`isJavaEscapedCharacter(char character)` Determines whether the given character should be escaped when being part of a string, i.e.
`static boolean`	`isParameter(char character)` Determines whether the given character is the character used to identify an input parameter, either a named parameter or position parameter.
`static boolean`	`isQuote(char character)` Determines whether the given character is the single or double quote.
`static java.lang.String`	`quote(java.lang.String text)` Returns the given string literal by wrapping it with single quotes.
`static void`	`reposition(java.lang.CharSequence query1, int[] positions, java.lang.CharSequence query2)` Adjusts the positions contained by the given array of either one or two elements, which is based on the given query1, by translating those positions to be at the equivalent position within query2.
`static int`	`repositionCursor(java.lang.CharSequence query1, int position1, java.lang.CharSequence query2)` Adjusts the position, which is based on the given query1, by translating it to be at the equivalent position within query2.
`static void`	`repositionJava(java.lang.CharSequence query, int[] positions)` Re-adjusts the given positions, which is based on the non-escaped version of the given query, by making sure it is pointing at the same position within query, which contains references (escape characters).
`static boolean`	`startWithIgnoreCase(java.lang.String string, java.lang.String prefix)` Determines whether the given string starts with the given prefix and ignores the case.
`static boolean`	`stringIsEmpty(java.lang.CharSequence text)` Determines whether the specified string is `null`, empty, or contains only whitespace characters.
`static boolean`	`stringIsNotEmpty(java.lang.CharSequence text)` Determines whether the specified string is NOT `null`, NOT empty, or contains at least one non-whitespace character.
`static boolean`	`stringsAreDifferentIgnoreCase(java.lang.CharSequence value1, java.lang.CharSequence value2)` Determines whether the two sequence of characters are different, with the appropriate `null` checks and the case is ignored.
`static boolean`	`stringsAreEqualIgnoreCase(java.lang.CharSequence value1, java.lang.CharSequence value2)` Determines whether the two sequence of characters are equal or equivalent, with the appropriate `null` checks and the case is ignored.
`static java.lang.String`	`unescape(java.lang.CharSequence value, int[] position)` Converts the string representation of the escape characters contained by the given `CharSequence` into the actual escape characters.
`static java.lang.String`	`unquote(java.lang.String text)` Returns the string literal without the single or double quotes.
`static boolean`	`valuesAreDifferent(java.lang.Object value1, java.lang.Object value2)` Determines whether the values are different, with the appropriate `null` checks.
`static boolean`	`valuesAreEqual(java.lang.Object value1, java.lang.Object value2)` Determines whether the values are equal or equivalent, with the appropriate `null` checks.

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

- Field Detail
  - DOUBLE_REGEXP
```
public static java.util.regex.Pattern DOUBLE_REGEXP
```
    The Pattern representing the regular expression of a numerical value as a double.
  - EMPTY_ARRAY
```
public static final java.lang.Object[] EMPTY_ARRAY
```
    The constant of an empty array.
  - EMPTY_STRING
```
public static final java.lang.String EMPTY_STRING
```
    The constant for an empty string.
    
    See Also:
    Constant Field Values
  - EMPTY_STRING_ARRAY
```
public static final java.lang.String[] EMPTY_STRING_ARRAY
```
    The constant of an empty String array.
  - FLOAT_REGEXP
```
public static java.util.regex.Pattern FLOAT_REGEXP
```
    The Pattern representing the regular expression of a numerical value as a float.
  - INTEGER_REGEXP
```
public static java.util.regex.Pattern INTEGER_REGEXP
```
    The Pattern representing the regular expression of a numerical value as an integer.
  - LONG_REGEXP
```
public static java.util.regex.Pattern LONG_REGEXP
```
    The Pattern representing the regular expression of a numerical value as a long.
- Method Detail
  - escape
```
public static java.lang.String escape(java.lang.CharSequence value,
                      int[] position)
```
    Converts the escape characters contained in the given CharSequence to their literal representation. For example, '\b' is converted to '\\b'.
    
    Parameters:
    value - The sequence of characters to convert any escape character
    position - This is a one element array that needs to be adjusted when an escape character is converted
    
    Returns:
    The new sequence of characters that does not contain any escape character but it's literal representation
  - isFunctionExpression
```
public static boolean isFunctionExpression(WordParser wordParser,
                           java.lang.String identifier)
```
    Determines whether the JPQL fragment is an expression of the form <IDENTIFIER>(.
    
    Parameters:
    wordParser - The text to parse based on the current position of the cursor
    identifier - The identifier to verify if it's for an expression or for possibly for a variable name
    
    Returns:
    true if the identifier is followed by '('; false otherwise
  - isJavaEscapedCharacter
```
public static boolean isJavaEscapedCharacter(char character)
```
    Determines whether the given character should be escaped when being part of a string, i.e. '\r' should be "\\r".
    
    Parameters:
    character - The character to check if it can directly be used in a string or should be escaped
    
    Returns:
    true if the given character cannot be used directly in a string
    Since:
    
    2.5
  - isParameter
```
public static boolean isParameter(char character)
```
    Determines whether the given character is the character used to identify an input parameter, either a named parameter or position parameter.
    
    Parameters:
    character - The character to check if it's a parameter
    
    Returns:
    true if the given character is either : or ?; false otherwise
  - isQuote
```
public static boolean isQuote(char character)
```
    Determines whether the given character is the single or double quote.
    
    Parameters:
    character - The character to check if it's a quote
    
    Returns:
    true if the given character is either ' or "; false otherwise
  - quote
```
public static java.lang.String quote(java.lang.String text)
```
    Returns the given string literal by wrapping it with single quotes. Any single quote within the string will be escaped with another single quote.
    
    Parameters:
    text - The original text to quote
    
    Returns:
    The quoted text
    Since:
    
    2.4
  - reposition
```
public static void reposition(java.lang.CharSequence query1,
              int[] positions,
              java.lang.CharSequence query2)
```
    Adjusts the positions contained by the given array of either one or two elements, which is based on the given query1, by translating those positions to be at the equivalent position within query2.
    Important: The two JPQL queries should contain the same characters but the amount of whitespace can differ. One cannot have the escape characters and the other one has the Unicode characters.
    
    Parameters:
    query1 - The query where the positions are pointing
    positions - An array of either one or two elements positioned within query1
    query2 - The query for which the positions might need adjustment
    Since:
    
    2.5
  - repositionCursor
```
public static int repositionCursor(java.lang.CharSequence query1,
                   int position1,
                   java.lang.CharSequence query2)
```
    Adjusts the position, which is based on the given query1, by translating it to be at the equivalent position within query2.
    Important: The two JPQL queries should contain the same characters but the amount of whitespace can differ. One cannot have the escape characters and the other one has the Unicode characters.
    
    Parameters:
    query1 - The query where the positions are pointing
    position - The position of a cursor within query1
    query2 - The query for which the position might need adjustment
    
    Returns:
    The adjusted position by moving it based on the difference between query1 and query2
    See Also:
    reposition(CharSequence, int[], CharSequence)
  - repositionJava
```
public static void repositionJava(java.lang.CharSequence query,
                  int[] positions)
```
    Re-adjusts the given positions, which is based on the non-escaped version of the given query, by making sure it is pointing at the same position within query, which contains references (escape characters).
    The escape characters are either \b, \t, \n, \f, \r, \", \' and \0 through \7.
    Important: The given query should contain the exact same amount of whitespace than the query used to calculate the given positions.
    
    Parameters:
    query - The query that may contain escape characters
    positions - The position within the non-escaped version of the given query, which is either a single element position or two positions that is used as a text range
    Since:
    
    2.5
  - startWithIgnoreCase
```
public static boolean startWithIgnoreCase(java.lang.String string,
                          java.lang.String prefix)
```
    Determines whether the given string starts with the given prefix and ignores the case. If the prefix is null or an empty string, then true is always returned.
    
    Parameters:
    string - The string to check if its beginning matches the prefix
    prefix - The prefix used to test matching the beginning of the sequence of characters
    
    Returns:
    true if the given string begins with the given prefix and ignores the case; false otherwise
    Since:
    
    2.5
  - stringIsEmpty
```
public static boolean stringIsEmpty(java.lang.CharSequence text)
```
    Determines whether the specified string is null, empty, or contains only whitespace characters.
    
    Parameters:
    text - The sequence of character to test if it is null or only contains whitespace
    
    Returns:
    true if the given string is null or only contains whitespace; false otherwise
  - stringIsNotEmpty
```
public static boolean stringIsNotEmpty(java.lang.CharSequence text)
```
    Determines whether the specified string is NOT null, NOT empty, or contains at least one non-whitespace character.
    
    Parameters:
    text - The sequence of character to test if it is NOT null or does not only contain whitespace
    
    Returns:
    true if the given string is NOT null or has at least one non-whitespace character; false otherwise
  - stringsAreDifferentIgnoreCase
```
public static boolean stringsAreDifferentIgnoreCase(java.lang.CharSequence value1,
                                    java.lang.CharSequence value2)
```
    Determines whether the two sequence of characters are different, with the appropriate null checks and the case is ignored.
    
    Parameters:
    value1 - The first value to check for equality and equivalency
    value2 - The second value to check for equality and equivalency
    
    Returns:
    true if both values are different; false otherwise
  - stringsAreEqualIgnoreCase
```
public static boolean stringsAreEqualIgnoreCase(java.lang.CharSequence value1,
                                java.lang.CharSequence value2)
```
    Determines whether the two sequence of characters are equal or equivalent, with the appropriate null checks and the case is ignored.
    
    Parameters:
    value1 - The first value to check for equality and equivalency
    value2 - The second value to check for equality and equivalency
    
    Returns:
    true if both values are null, equal or equivalent; false otherwise
  - unescape
```
public static java.lang.String unescape(java.lang.CharSequence value,
                        int[] position)
```
    Converts the string representation of the escape characters contained by the given CharSequence into the actual escape characters. For example, the string '\\b' is converted into the character value '\b'.
    
    Parameters:
    value - The sequence of characters to convert to an escaped version
    position - This is a one element array that needs to be adjusted when an escape character is converted
    
    Returns:
    The new sequence of characters that contains escape characters rather than their string representation
  - unquote
```
public static java.lang.String unquote(java.lang.String text)
```
    Returns the string literal without the single or double quotes. Any two consecutive single quotes will be converted into a single quote.
    
    Parameters:
    text - The original text to unquote if it has ' at the beginning and the end
    
    Returns:
    The unquoted text
  - valuesAreDifferent
```
public static boolean valuesAreDifferent(java.lang.Object value1,
                         java.lang.Object value2)
```
    Determines whether the values are different, with the appropriate null checks.
    
    Parameters:
    value1 - The first value to check for equality and equivalency
    value2 - The second value to check for equality and equivalency
    
    Returns:
    true if both values are different; true if they are both null, equal or equivalent
  - valuesAreEqual
```
public static boolean valuesAreEqual(java.lang.Object value1,
                     java.lang.Object value2)
```
    Determines whether the values are equal or equivalent, with the appropriate null checks.
    
    Parameters:
    value1 - The first value to check for equality and equivalency
    value2 - The second value to check for equality and equivalency
    
    Returns:
    true if both values are null, equal or equivalent; false otherwise

Class ExpressionTools

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DOUBLE_REGEXP

EMPTY_ARRAY

EMPTY_STRING

EMPTY_STRING_ARRAY

FLOAT_REGEXP

INTEGER_REGEXP

LONG_REGEXP

Method Detail

escape

isFunctionExpression

isJavaEscapedCharacter

isParameter

isQuote

quote

reposition

repositionCursor

repositionJava

startWithIgnoreCase

stringIsEmpty

stringIsNotEmpty

stringsAreDifferentIgnoreCase

stringsAreEqualIgnoreCase

unescape

unquote

valuesAreDifferent

valuesAreEqual