ERXQ (Project Wonder Reference Documentation)

java.lang.Object
- er.extensions.eof.ERXQ

public class ERXQ
extends Object

ERXQ provides lots of much shorter methods of constructing EOQualifiers than the very verbose style that you normally have to use. For instance ...

   EOQualifier qualifier = new ERXAndQualifier(
            new NSArray(new Object[] {
                   new ERXKeyValueQualifier("name", EOQualifier.QualifierOperatorsEquals, "Mike"),
                   new ERXKeyValueQualifier("admin", EOQualifier.QualifierOperatorsEquals,
                   Boolean.TRUE) }));

... becomes ...

EOQualifier qualifier = ERXQ.and(ERXQ.equals("name", "Mike"), ERXQ.isTrue("admin"));

Author:: mschrag

Field Summary

Fields
Modifier and Type	Field and Description
`static NSSelector`	`CONTAINS` Equivalent to EOQualifier.QualifierOperatorContains
`static NSSelector`	`EQ` Equivalent to EOQualifier.QualifierOperatorEqual
`static NSSelector`	`GT` Equivalent to EOQualifier.QualifierOperatorGreaterThan
`static NSSelector`	`GTEQ` Equivalent to EOQualifier.QualifierOperatorGreaterThanOrEqualTo
`static NSSelector`	`ILIKE` Equivalent to EOQualifier.QualifierOperatorCaseInsensitiveLike
`static NSSelector`	`LIKE` Equivalent to EOQualifier.QualifierOperatorLike
`static NSSelector`	`LT` Equivalent to EOQualifier.QualifierOperatorLessThan
`static NSSelector`	`LTEQ` Equivalent to EOQualifier.QualifierOperatorLessThanOrEqualTo
`static NSSelector`	`NE` Equivalent to EOQualifier.QualifierOperatorNotEqual

Constructor Summary

Constructors
Constructor and Description

ERXQ()

Constructors
Constructor and Description
`ERXQ()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static ERXAndQualifier`	`and(EOQualifier... qualifiersArray)` Equivalent to new ERXAndQualifier(new NSArray(qualifiersArray).
`static ERXAndQualifier`	`and(NSArray<? extends EOQualifier> qualifiers)` Equivalent to new ERXAndQualifier(new NSArray(qualifiersArray).
`static EOQualifier`	`between(String key, Object lowerBound, Object upperBound)` Equivalent to key > lowerBound and key < upperBound (exclusive).
`static EOQualifier`	`between(String key, Object lowerBound, Object upperBound, boolean inclusive)` Equivalent to key >= lowerBound and key <= upperBound (inclusive).
`static ERXKeyValueQualifier`	`compare(String key, NSSelector operator, Object value)` Equivalent to new ERXKeyValueQualifier(key, operator, value);
`static ERXKeyValueQualifier`	`contains(String key, String value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorCaseInsensitiveLike, "" + value + "").
`static ERXOrQualifier`	`containsAll(NSArray<String> keys, String tokensWithWhitespace)` Returns a qualifier that evalutes to true when the value of any of the given keys contains all of the given tokens (insensitively) in the search string.
`static ERXAndQualifier`	`containsAll(String key, String tokensWithWhitespace)` Returns a qualifier that evalutes to true when the value of the given key contains all of the given tokens (insensitively) in the search string.
`static ERXAndQualifier`	`containsAll(String key, String[] tokens)` Returns a qualifier that evalutes to true when the value of the given key contains all of the given tokens (insensitively).
`static ERXAndQualifier`	`containsAllInAny(String[] keys, String tokensWithWhitespace)` Returns a qualifier that evaluates to true when all values in the given tokens are found when searching across any of the keypaths.
`static ERXAndQualifier`	`containsAllInAny(String[] keys, String[] tokens)` Returns a qualifier that evaluates to true when all values in the given tokens are found when searching across any of the keypaths.
`static ERXOrQualifier`	`containsAny(NSArray<String> keys, String tokensWithWhitespace)` Returns a qualifier that evalutes to true when the value of any of the given keys contains any of the given tokens (insensitively) in the search string.
`static ERXOrQualifier`	`containsAny(String key, String tokensWithWhitespace)` Returns a qualifier that evalutes to true when the value of the given key contains any of the given tokens (insensitively) in the search string.
`static ERXOrQualifier`	`containsAny(String key, String[] tokens)` Returns a qualifier that evalutes to true when the value of the given key contains any of the given tokens (insensitively).
`static ERXKeyValueQualifier`	`containsObject(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorContains, value).
`static ERXKeyValueQualifier`	`endsWith(String key, String value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorLike, "*" + value).
`static ERXKeyValueQualifier`	`endsWithInsensitive(String key, String value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorCaseInsensitiveLike, "*" + value).
`static <T> ERXKeyComparisonQualifier`	`equals(ERXKey<T> key, ERXKey<T> value)` Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorEqual, value);
`static ERXKeyValueQualifier`	`equals(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, value);
`static NSArray<EOKeyValueQualifier>`	`extractKeyValueQualifiers(EOQualifier qualifier)` Analyzes the given qualifier and returns all found `EOKeyValueQualifier` objects contained within.
`static void`	`filter(NSMutableArray<?> array, EOQualifier qualifier)` Equivalent to EOQualifier.filterArrayWithQualifier(NSMutableArray, EOQualifier)
`static <T> NSArray<T>`	`filtered(NSArray<T> array, EOQualifier qualifier)` Equivalent to EOQualifier.filteredArrayWithQualifier(NSArray, EOQualifier)
`static <T> T`	`first(NSArray<T> array, EOQualifier qualifier)` Returns the first object that matches the qualifier in the given array (or null if there is no match).
`static <T> ERXKeyComparisonQualifier`	`greaterThan(ERXKey<T> key, ERXKey<T> value)` Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorGreaterThan, value);
`static ERXKeyValueQualifier`	`greaterThan(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorGreaterThan, value);
`static <T> ERXKeyComparisonQualifier`	`greaterThanOrEqualTo(ERXKey<T> key, ERXKey<T> value)` Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorGreaterThanOrEqualTo, value);
`static ERXKeyValueQualifier`	`greaterThanOrEqualTo(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorGreaterThanOrEqualTo, value);
`static ERXKeyValueQualifier`	`has(String key, NSArray values)` Equivalent to new ERXToManyQualifier(key, values);
`static ERXKeyValueQualifier`	`hasAtLeast(String key, NSArray values, int min)` Equivalent to new ERXToManyQualifier(key, values);
`static ERXKeyValueQualifier`	`hasValues(String key, NSArray values)` Equivalent to new ERXInQualifier(key, values);
`static ERXOrQualifier`	`in(String key, NSArray<?> values)` Equivalent to a new ERXOrQualifier of EOKeyValueQualifier with key equals value for each value.
`static ERXOrQualifier`	`inObjects(String key, Object... values)` Equivalent to a new ERXOrQualifier of EOKeyValueQualifier with key equals value for each value.
`static EOQualifier`	`is(ERXGenericRecord value)` Return an identity qualifier to use with ERXExistsQualifier for example
`static ERXKeyValueQualifier`	`is(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, value);
`static ERXKeyValueQualifier`	`isFalse(String key)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, Boolean.FALSE);
`static EOQualifier`	`isIn(NSArray<? extends ERXGenericRecord> valueArray)` Return a OR qualifier of identity qualifiers using each value from the param array
`static ERXKeyValueQualifier`	`isNotNull(String key)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorNotEqual, null);
`static ERXKeyValueQualifier`	`isNull(String key)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, null);
`static ERXKeyValueQualifier`	`isNull(String key, boolean yesOrNo)` Returns isNull or isNotNull depending on the value of yesOrNo.
`static ERXKeyValueQualifier`	`isTrue(String key)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, Boolean.TRUE);
`static String`	`keyPath(String... elements)` Generates a key path from a var args list of strings.
`static <T> ERXKeyComparisonQualifier`	`lessThan(ERXKey<T> key, ERXKey<T> value)` Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorLessThan, value);
`static ERXKeyValueQualifier`	`lessThan(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorLessThan, value);
`static <T> ERXKeyComparisonQualifier`	`lessThanOrEqualTo(ERXKey<T> key, ERXKey<T> value)` Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorLessThanOrEqualTo, value);
`static ERXKeyValueQualifier`	`lessThanOrEqualTo(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorLessThanOrEqualTo, value);
`static ERXKeyValueQualifier`	`like(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorLike, value);
`static ERXKeyValueQualifier`	`likeInsensitive(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorCaseInsensitiveLike, value);
`static ERXKeyValueQualifier`	`matches(String key, String value)` Equivalent to new ERXRegExQualifier(key, value);
`static EOQualifier`	`matchingValues(Object... values)` Inspired by EOUtilities.objectsWithValues method, creates EOKeyValueQualifiers for a variable-length list of parameters, combines these qualifier into an EOAndQualifier and returns that qualifier.
`static ERXNotQualifier`	`not(EOQualifier qualifier)` Equivalent to new ERXNotQualifier(qualifier);
`static <T> ERXKeyComparisonQualifier`	`notEquals(ERXKey<T> key, ERXKey<T> value)` Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorNotEqual, value);
`static ERXKeyValueQualifier`	`notEquals(String key, Object value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorNotEqual, value);
`static ERXAndQualifier`	`notIn(String key, NSArray values)` Equivalent to a new ERXAndQualifier of EONotQualifier(EOKeyValueQualifier) with key equals value for each value.
`static ERXAndQualifier`	`notInObjects(String key, Object... values)` Equivalent to a new ERXAndQualifier of EONotQualifier(EOKeyValueQualifier) with key equals value for each value.
`static <T> T`	`one(NSArray<T> array, EOQualifier qualifier)` Returns the one object that matches the qualifier in the given array (or null if there is no match).
`static ERXOrQualifier`	`or(EOQualifier... qualifiersArray)` Equivalent to new ERXOrQualifier(new NSArray(qualifiersArray).
`static ERXOrQualifier`	`or(NSArray<? extends EOQualifier> qualifiers)` Equivalent to new ERXOrQualifier(new NSArray(qualifiersArray).
`static EOQualifier`	`replaceQualifierWithQualifier(EOQualifier qualifier, EOQualifier searchFor, EOQualifier replaceWith)` Takes a qualifier and searches for the given qualifier within to replace it with another one.
`static <T> T`	`requiredOne(NSArray<T> array, EOQualifier qualifier)` Returns the one object that matches the qualifier in the given array (or throws if there is no match).
`static ERXKeyValueQualifier`	`startsWith(String key, String value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorLike, value + "*").
`static ERXKeyValueQualifier`	`startsWithInsensitive(String key, String value)` Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorCaseInsensitiveLike, value + "*").

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

- Field Detail
  - EQ
```
public static final NSSelector EQ
```
    Equivalent to EOQualifier.QualifierOperatorEqual
  - NE
```
public static final NSSelector NE
```
    Equivalent to EOQualifier.QualifierOperatorNotEqual
  - LT
```
public static final NSSelector LT
```
    Equivalent to EOQualifier.QualifierOperatorLessThan
  - GT
```
public static final NSSelector GT
```
    Equivalent to EOQualifier.QualifierOperatorGreaterThan
  - LTEQ
```
public static final NSSelector LTEQ
```
    Equivalent to EOQualifier.QualifierOperatorLessThanOrEqualTo
  - GTEQ
```
public static final NSSelector GTEQ
```
    Equivalent to EOQualifier.QualifierOperatorGreaterThanOrEqualTo
  - CONTAINS
```
public static final NSSelector CONTAINS
```
    Equivalent to EOQualifier.QualifierOperatorContains
  - LIKE
```
public static final NSSelector LIKE
```
    Equivalent to EOQualifier.QualifierOperatorLike
  - ILIKE
```
public static final NSSelector ILIKE
```
    Equivalent to EOQualifier.QualifierOperatorCaseInsensitiveLike
- Constructor Detail
  - ERXQ
```
public ERXQ()
```
- Method Detail
  - filtered
```
public static <T> NSArray<T> filtered(NSArray<T> array,
                                      EOQualifier qualifier)
```
    Equivalent to EOQualifier.filteredArrayWithQualifier(NSArray, EOQualifier)
    
    Type Parameters:
    
    T - the type of the array
    
    Parameters:
    
    array - the array to filter
    
    qualifier - the qualifier to filter with
    
    Returns:
    
    the filtered array
  - filter
```
public static void filter(NSMutableArray<?> array,
                          EOQualifier qualifier)
```
    Equivalent to EOQualifier.filterArrayWithQualifier(NSMutableArray, EOQualifier)
    
    Parameters:
    
    array - the array to filter (in place)
    
    qualifier - the qualifier to filter with
  - one
```
public static <T> T one(NSArray<T> array,
                        EOQualifier qualifier)
```
    Returns the one object that matches the qualifier in the given array (or null if there is no match).
    
    Type Parameters:
    
    T - the type of the objects
    
    Parameters:
    
    array - the array to filter
    
    qualifier - the qualifier to filter on
    
    Returns:
    
    one matching object or null
    
    Throws:
    
    IllegalStateException - if more than one object matched
  - first
```
public static <T> T first(NSArray<T> array,
                          EOQualifier qualifier)
```
    Returns the first object that matches the qualifier in the given array (or null if there is no match).
    
    Type Parameters:
    
    T - the type of the objects
    
    Parameters:
    
    array - the array to filter
    
    qualifier - the qualifier to filter on
    
    Returns:
    
    one matching object or null
  - requiredOne
```
public static <T> T requiredOne(NSArray<T> array,
                                EOQualifier qualifier)
```
    Returns the one object that matches the qualifier in the given array (or throws if there is no match).
    
    Type Parameters:
    
    T - the type of the objects
    
    Parameters:
    
    array - the array to filter
    
    qualifier - the qualifier to filter on
    
    Returns:
    
    one matching object
    
    Throws:
    
    IllegalStateException - if more than one object matched
    
    NoSuchElementException - if no objects matched
  - or
```
public static ERXOrQualifier or(EOQualifier... qualifiersArray)
```
    Equivalent to new ERXOrQualifier(new NSArray(qualifiersArray). Nulls are skipped.
    
    Parameters:
    
    qualifiersArray - the array of qualifiers to or
    
    Returns:
    
    and EOOrQualifier
  - or
```
public static ERXOrQualifier or(NSArray<? extends EOQualifier> qualifiers)
```
    Equivalent to new ERXOrQualifier(new NSArray(qualifiersArray).
    
    Parameters:
    
    qualifiers - the NSArray of qualifiers to or
    
    Returns:
    
    an ERXOrQualifier
  - and
```
public static ERXAndQualifier and(EOQualifier... qualifiersArray)
```
    Equivalent to new ERXAndQualifier(new NSArray(qualifiersArray). Nulls are skipped.
    
    Parameters:
    
    qualifiersArray - the array of qualifiers to and
    
    Returns:
    
    and EOAndQualifier
  - and
```
public static ERXAndQualifier and(NSArray<? extends EOQualifier> qualifiers)
```
    Equivalent to new ERXAndQualifier(new NSArray(qualifiersArray).
    
    Parameters:
    
    qualifiers - the NSArray of qualifiers to and
    
    Returns:
    
    an ERXAndQualifier
  - like
```
public static ERXKeyValueQualifier like(String key,
                                        Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorLike, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - likeInsensitive
```
public static ERXKeyValueQualifier likeInsensitive(String key,
                                                   Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorCaseInsensitiveLike, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - matches
```
public static ERXKeyValueQualifier matches(String key,
                                           String value)
```
    Equivalent to new ERXRegExQualifier(key, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - hasValues
```
public static ERXKeyValueQualifier hasValues(String key,
                                             NSArray values)
```
    Equivalent to new ERXInQualifier(key, values);
    
    Parameters:
    
    key - the key
    
    values - the values
    
    Returns:
    
    an EOKeyValueQualifier
  - has
```
public static ERXKeyValueQualifier has(String key,
                                       NSArray values)
```
    Equivalent to new ERXToManyQualifier(key, values);
    
    Parameters:
    
    key - the key
    
    values - the values
    
    Returns:
    
    an EOKeyValueQualifier
  - hasAtLeast
```
public static ERXKeyValueQualifier hasAtLeast(String key,
                                              NSArray values,
                                              int min)
```
    Equivalent to new ERXToManyQualifier(key, values);
    
    Parameters:
    
    key - the key
    
    values - the values
    
    min - the minimum number of objects from values to match
    
    Returns:
    
    an EOKeyValueQualifier
  - equals
```
public static ERXKeyValueQualifier equals(String key,
                                          Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - equals
```
public static <T> ERXKeyComparisonQualifier equals(ERXKey<T> key,
                                                   ERXKey<T> value)
```
    Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorEqual, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an ERXKeyComparisonQualifier
  - isIn
```
public static EOQualifier isIn(NSArray<? extends ERXGenericRecord> valueArray)
```
    Return a OR qualifier of identity qualifiers using each value from the param array
    
    Parameters:
    
    valueArray - the array of values
    
    Returns:
    
    an EOQualifier
    
    Since:
    
    May 16, 2016
    
    Author:
    
    Samuel Pelletier
  - is
```
public static EOQualifier is(ERXGenericRecord value)
```
    Return an identity qualifier to use with ERXExistsQualifier for example
    
    Parameters:
    
    value - the value
    
    Returns:
    
    an EOQualifier
    
    Since:
    
    May 16, 2016
    
    Author:
    
    Samuel Pelletier
  - is
```
public static ERXKeyValueQualifier is(String key,
                                      Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - isNull
```
public static ERXKeyValueQualifier isNull(String key,
                                          boolean yesOrNo)
```
    Returns isNull or isNotNull depending on the value of yesOrNo.
    
    Parameters:
    
    key - the key
    
    yesOrNo - if true, returns isNull, if false, returns isNotNull
    
    Returns:
    
    the EOKeyValueQualifier
  - isNull
```
public static ERXKeyValueQualifier isNull(String key)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, null);
    
    Parameters:
    
    key - the key
    
    Returns:
    
    an EOKeyValueQualifier
  - isNotNull
```
public static ERXKeyValueQualifier isNotNull(String key)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorNotEqual, null);
    
    Parameters:
    
    key - the key
    
    Returns:
    
    an EOKeyValueQualifier
  - isTrue
```
public static ERXKeyValueQualifier isTrue(String key)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, Boolean.TRUE);
    
    Parameters:
    
    key - the key
    
    Returns:
    
    an EOKeyValueQualifier
  - isFalse
```
public static ERXKeyValueQualifier isFalse(String key)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorEqual, Boolean.FALSE);
    
    Parameters:
    
    key - the key
    
    Returns:
    
    an EOKeyValueQualifier
  - notEquals
```
public static ERXKeyValueQualifier notEquals(String key,
                                             Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorNotEqual, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - notEquals
```
public static <T> ERXKeyComparisonQualifier notEquals(ERXKey<T> key,
                                                      ERXKey<T> value)
```
    Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorNotEqual, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an ERXKeyComparisonQualifier
  - lessThan
```
public static ERXKeyValueQualifier lessThan(String key,
                                            Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorLessThan, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - lessThan
```
public static <T> ERXKeyComparisonQualifier lessThan(ERXKey<T> key,
                                                     ERXKey<T> value)
```
    Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorLessThan, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an ERXKeyComparisonQualifier
  - greaterThan
```
public static ERXKeyValueQualifier greaterThan(String key,
                                               Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorGreaterThan, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - greaterThan
```
public static <T> ERXKeyComparisonQualifier greaterThan(ERXKey<T> key,
                                                        ERXKey<T> value)
```
    Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorGreaterThan, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an ERXKeyComparisonQualifier
  - lessThanOrEqualTo
```
public static ERXKeyValueQualifier lessThanOrEqualTo(String key,
                                                     Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorLessThanOrEqualTo, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - lessThanOrEqualTo
```
public static <T> ERXKeyComparisonQualifier lessThanOrEqualTo(ERXKey<T> key,
                                                              ERXKey<T> value)
```
    Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorLessThanOrEqualTo, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an ERXKeyComparisonQualifier
  - greaterThanOrEqualTo
```
public static ERXKeyValueQualifier greaterThanOrEqualTo(String key,
                                                        Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.QualifierOperatorGreaterThanOrEqualTo, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - greaterThanOrEqualTo
```
public static <T> ERXKeyComparisonQualifier greaterThanOrEqualTo(ERXKey<T> key,
                                                                 ERXKey<T> value)
```
    Equivalent to new ERXKeyComparisonQualifier(key, EOQualifier.QualifierOperatorGreaterThanOrEqualTo, value);
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an ERXKeyComparisonQualifier
  - not
```
public static ERXNotQualifier not(EOQualifier qualifier)
```
    Equivalent to new ERXNotQualifier(qualifier);
    
    Parameters:
    
    qualifier - the qualifier to not
    
    Returns:
    
    an EONotQualifier
  - compare
```
public static ERXKeyValueQualifier compare(String key,
                                           NSSelector operator,
                                           Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, operator, value);
    
    Parameters:
    
    key - the key
    
    operator - ERXQ.EQ, NE, GT, LT, etc
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - inObjects
```
public static ERXOrQualifier inObjects(String key,
                                       Object... values)
```
    Equivalent to a new ERXOrQualifier of EOKeyValueQualifier with key equals value for each value.
    
    Parameters:
    
    key - the key
    
    values - the values
    
    Returns:
    
    an EOQualifier
  - notInObjects
```
public static ERXAndQualifier notInObjects(String key,
                                           Object... values)
```
    Equivalent to a new ERXAndQualifier of EONotQualifier(EOKeyValueQualifier) with key equals value for each value.
    
    Parameters:
    
    key - the key
    
    values - the values
    
    Returns:
    
    an EOQualifier
  - in
```
public static ERXOrQualifier in(String key,
                                NSArray<?> values)
```
    Equivalent to a new ERXOrQualifier of EOKeyValueQualifier with key equals value for each value.
    
    Parameters:
    
    key - the key
    
    values - the values
    
    Returns:
    
    an EOQualifier
  - notIn
```
public static ERXAndQualifier notIn(String key,
                                    NSArray values)
```
    Equivalent to a new ERXAndQualifier of EONotQualifier(EOKeyValueQualifier) with key equals value for each value.
    
    Parameters:
    
    key - the key
    
    values - the values
    
    Returns:
    
    an EOQualifier
  - between
```
public static EOQualifier between(String key,
                                  Object lowerBound,
                                  Object upperBound)
```
    Equivalent to key > lowerBound and key < upperBound (exclusive). Not that this does not return an ERXBetweenQualifier.
    
    Parameters:
    
    key - the key
    
    lowerBound - the lower bound value
    
    upperBound - the upper bound value
    
    Returns:
    
    the qualifier
  - between
```
public static EOQualifier between(String key,
                                  Object lowerBound,
                                  Object upperBound,
                                  boolean inclusive)
```
    Equivalent to key >= lowerBound and key <= upperBound (inclusive). Not that this does not return an ERXBetweenQualifier.
    
    Parameters:
    
    key - the key
    
    lowerBound - the lower bound value
    
    upperBound - the upper bound value
    
    inclusive - if the lowerBound and upperBound should be inclusive
    
    Returns:
    
    the qualifier
  - startsWith
```
public static ERXKeyValueQualifier startsWith(String key,
                                              String value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorLike, value + "*").
    
    Parameters:
    
    key - the key
    
    value - the substring value
    
    Returns:
    
    an EOKeyValueQualifier
  - startsWithInsensitive
```
public static ERXKeyValueQualifier startsWithInsensitive(String key,
                                                         String value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorCaseInsensitiveLike, value + "*").
    
    Parameters:
    
    key - the key
    
    value - the substring value
    
    Returns:
    
    an EOKeyValueQualifier
  - endsWith
```
public static ERXKeyValueQualifier endsWith(String key,
                                            String value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorLike, "*" + value).
    
    Parameters:
    
    key - the key
    
    value - the substring value
    
    Returns:
    
    an EOKeyValueQualifier
  - endsWithInsensitive
```
public static ERXKeyValueQualifier endsWithInsensitive(String key,
                                                       String value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorCaseInsensitiveLike, "*" + value).
    
    Parameters:
    
    key - the key
    
    value - the substring value
    
    Returns:
    
    an EOKeyValueQualifier
  - containsObject
```
public static ERXKeyValueQualifier containsObject(String key,
                                                  Object value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorContains, value).
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    an EOKeyValueQualifier
  - contains
```
public static ERXKeyValueQualifier contains(String key,
                                            String value)
```
    Equivalent to new ERXKeyValueQualifier(key, EOQualifier.OperatorCaseInsensitiveLike, "*" + value + "*").
    
    Parameters:
    
    key - the key
    
    value - the substring value
    
    Returns:
    
    an EOKeyValueQualifier
  - containsAny
```
public static ERXOrQualifier containsAny(NSArray<String> keys,
                                         String tokensWithWhitespace)
```
    Returns a qualifier that evalutes to true when the value of any of the given keys contains any of the given tokens (insensitively) in the search string. The search string will be tokenized by splitting on space characters.
    
    Parameters:
    
    keys - the keys
    
    tokensWithWhitespace - a whitespace separated list of tokens to search for
    
    Returns:
    
    an ERXOrQualifier
  - containsAny
```
public static ERXOrQualifier containsAny(String key,
                                         String tokensWithWhitespace)
```
    Returns a qualifier that evalutes to true when the value of the given key contains any of the given tokens (insensitively) in the search string. The search string will be tokenized by splitting on space characters.
    
    Parameters:
    
    key - the key
    
    tokensWithWhitespace - a whitespace separated list of tokens to search for
    
    Returns:
    
    an ERXOrQualifier
  - containsAny
```
public static ERXOrQualifier containsAny(String key,
                                         String[] tokens)
```
    Returns a qualifier that evalutes to true when the value of the given key contains any of the given tokens (insensitively).
    
    Parameters:
    
    key - the key
    
    tokens - the list of tokens to search for
    
    Returns:
    
    an ERXOrQualifier
  - containsAll
```
public static ERXOrQualifier containsAll(NSArray<String> keys,
                                         String tokensWithWhitespace)
```
    Returns a qualifier that evalutes to true when the value of any of the given keys contains all of the given tokens (insensitively) in the search string. The search string will be tokenized by splitting on space characters.
    
    Parameters:
    
    keys - the keys
    
    tokensWithWhitespace - a whitespace separated list of tokens to search for
    
    Returns:
    
    an ERXOrQualifier
  - containsAll
```
public static ERXAndQualifier containsAll(String key,
                                          String tokensWithWhitespace)
```
    Returns a qualifier that evalutes to true when the value of the given key contains all of the given tokens (insensitively) in the search string. The search string will be tokenized by splitting on space characters.
    
    Parameters:
    
    key - the key
    
    tokensWithWhitespace - a whitespace separated list of tokens to search for
    
    Returns:
    
    an ERXAndQualifier
  - containsAll
```
public static ERXAndQualifier containsAll(String key,
                                          String[] tokens)
```
    Returns a qualifier that evalutes to true when the value of the given key contains all of the given tokens (insensitively).
    
    Parameters:
    
    key - the key
    
    tokens - the list of tokens to search for
    
    Returns:
    
    an ERXAndQualifier
  - containsAllInAny
```
public static ERXAndQualifier containsAllInAny(String[] keys,
                                               String tokensWithWhitespace)
```
    Returns a qualifier that evaluates to true when all values in the given tokens are found when searching across any of the keypaths. As an example, you could search for "Mike Schrag" across the keys (firstName, lastName) and it would find (firstName=Mike or lastName=Mike) and (firstName=Schrag or lastName=Schrag). Be careful of this one as it permutes quickly.
    
    Parameters:
    
    keys - keypaths to perform search in
    
    tokensWithWhitespace - tokens to search for
    
    Returns:
    
    an ERXAndQualifier
  - containsAllInAny
```
public static ERXAndQualifier containsAllInAny(String[] keys,
                                               String[] tokens)
```
    Returns a qualifier that evaluates to true when all values in the given tokens are found when searching across any of the keypaths. As an example, you could search for "Mike Schrag" across the keys (firstName, lastName) and it would find (firstName=Mike or lastName=Mike) and (firstName=Schrag or lastName=Schrag). Be careful of this one as it permutes quickly.
    
    Parameters:
    
    keys - keypaths to perform search in
    
    tokens - tokens to search for
    
    Returns:
    
    an ERXAndQualifier
  - keyPath
```
public static String keyPath(String... elements)
```
    Generates a key path from a var args list of strings. Reduces this mess:
```
 qualifiers.addObject(ERXQ.equals(Distribution.PUBLICATION + "." + Publication.AD + "." + Ad.STATE, DisplayAdStateMachine.ReadyForPrinting));
 
```
    to:
```
 qualifiers.addObject(ERXQ.equals(ERXQ.keyPath(Distribution.PUBLICATION, Publication.AD, Ad.STATE, DisplayAdStateMachine.ReadyForPrinting));
 
```
    Parameters:
    
    elements - one or more string to concatenate into a keyPath
    
    Returns:
    
    elements with "." between them to form a keypath
  - extractKeyValueQualifiers
```
public static NSArray<EOKeyValueQualifier> extractKeyValueQualifiers(EOQualifier qualifier)
```
    Analyzes the given qualifier and returns all found EOKeyValueQualifier objects contained within.
    
    Parameters:
    
    qualifier - qualifier to analyze
    
    Returns:
    
    array of found key value qualifiers
  - replaceQualifierWithQualifier
```
public static EOQualifier replaceQualifierWithQualifier(EOQualifier qualifier,
                                                        EOQualifier searchFor,
                                                        EOQualifier replaceWith)
```
    Takes a qualifier and searches for the given qualifier within to replace it with another one.
    
    Parameters:
    
    qualifier - the qualifier to modify
    
    searchFor - the qualifier to replace
    
    replaceWith - the qualifier that replaces the searched one
    
    Returns:
    
    modified qualifier
  - matchingValues
```
public static EOQualifier matchingValues(Object... values)
```
    Inspired by EOUtilities.objectsWithValues method, creates EOKeyValueQualifiers for a variable-length list of parameters, combines these qualifier into an EOAndQualifier and returns that qualifier. Values can be a dictionary, in which case the values are added to the EOQualifier list as EOKeyValueQualifier objects. Values can be an EOQualifier, which just gets included in the list of EOQualifiers. When String-Object pairs or ERXKey-Object pairs appear in the list, they are turned into an EOKeyValueQualifier and added to the list.
    An IllegalArgumentException is thrown if objects are not of the right type or if a bad sequence is used, such as a sequence of String-Object-Object or String-String-String.
    See er.extensions.eof.ERXEOControlUtilitiesTest in the ERXTest project for details.
    
    Parameters:
    
    values - a list of objects that can be used to create an EOQualifier. An NSDictionary or EOQualifier can stand alone in the list. A String or ERXKey must be followed by an Object.
    
    Returns:
    
    an EOQualifier

Class ERXQ

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EQ

NE

LT

GT

LTEQ

GTEQ

CONTAINS

LIKE

ILIKE

Constructor Detail

ERXQ

Method Detail

filtered

filter

one

first

requiredOne

or

or

and

and

like

likeInsensitive

matches

hasValues

has

hasAtLeast

equals

equals

isIn

is

is

isNull

isNull

isNotNull

isTrue

isFalse

notEquals

notEquals

lessThan

lessThan

greaterThan

greaterThan

lessThanOrEqualTo

lessThanOrEqualTo

greaterThanOrEqualTo

greaterThanOrEqualTo

not

compare

inObjects

notInObjects

in

notIn

between

between

startsWith

startsWithInsensitive

endsWith

endsWithInsensitive

containsObject

contains

containsAny

containsAny

containsAny

containsAll

containsAll

containsAll

containsAllInAny

containsAllInAny

keyPath

extractKeyValueQualifiers

replaceQualifierWithQualifier

matchingValues