Matchers (Glazed Lists)

java.lang.Object
- ca.odell.glazedlists.matchers.Matchers

public final class Matchers
extends java.lang.Object

A factory for creating Matchers.

Author:: Jesse Wilson

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <E> Matcher<E>`	`and(Matcher<? super E>... matchers)` Returns a Matcher which returns a match when all of the given `matchers` report a match.
`static <E> Matcher<E>`	`beanPropertyMatcher(java.lang.Class<E> beanClass, java.lang.String propertyName, java.lang.Object expectedValue)` Creates a `Matcher` that uses Reflection to compare the expectedValue of the specified property of an object to the `expectedValue`.
`static <E> boolean`	`contains(java.util.Collection<E> collection, Matcher<? super E> matcher)` Returns `true` if the given `collection` contains an element that satisfies the given `matcher`; `false` otherise.
`static <E> int`	`count(java.util.Collection<E> collection, Matcher<? super E> matcher)` Iterate through the specified collection and count all elements that match the specified matcher.
`static <E> Matcher<E>`	`falseMatcher()` Get a `Matcher` that always returns false, therefore matching nothing..
`static <E> boolean`	`filter(java.util.Collection<E> collection, Matcher<? super E> matcher)` Iterate through the specified collection and remove all elements that don't match the specified matcher.
`static <E> int`	`indexOf(java.util.List<E> list, Matcher<? super E> matcher)` Returns the index of the first element from the given `list` that satisfies the `matcher` or `-1` if no such element exists.
`static <E> Matcher<E>`	`invert(Matcher<E> original)` Get a `Matcher` that returns the opposite of the specified `Matcher`.
`static <E> Matcher<E>`	`isNotNull()` Get a `Matcher` that returns returns `true` iff it is given a `null` object.
`static <E> Matcher<E>`	`isNull()` Get a `Matcher` that returns returns `true` iff it is given a `non-null` object.
`static Matcher<java.lang.String>`	`nonNullAndNonEmptyString()` Get a `Matcher` that returns `true` iff it is given a `non-null` and `non-empty` String.
`static <E> Matcher<E>`	`or(Matcher<? super E>... matchers)` Returns a Matcher which returns a match when any of the given `matchers` reports a match.
`static Matcher<java.beans.PropertyChangeEvent>`	`propertyEventNameMatcher(boolean matchPropertyNames, java.lang.String... propertyNames)` Create a `Matcher` that uses the given `propertyNames` to match `PropertyChangeEvent`s by their property name.
`static <D extends java.lang.Comparable,E> Matcher<E>`	`rangeMatcher(D start, D end)` Creates a `Matcher` that matches `Comparable` objects for containment within the range between the given `start` and `end`.
`static <D extends java.lang.Comparable,E> Matcher<E>`	`rangeMatcher(D start, D end, Filterator<D,E> filterator)` Creates a `Matcher` that uses the given `filterator` to extract `Comparable` objects from filtered objects and compares those Comparables against the range between the given `start` and `end`.
`static <E> java.util.Collection<? super E>`	`select(java.util.Collection<E> collection, Matcher<? super E> matcher)` Add all elements from the given `collection` that satisfy the `matcher` to a new `ArrayList`.
`static <E> java.util.Collection<? super E>`	`select(java.util.Collection<E> collection, Matcher<? super E> matcher, java.util.Collection<? super E> results)` Add all elements from the given `collection` that satisfy the `matcher` to the given `results` Collection.
`static <E> E[]`	`select(E[] items, Matcher<? super E> matcher)` Return a new array containing only the `items` that satisfy the `matcher`.
`static <E> Matcher<E>`	`trueMatcher()` Get a `Matcher` that always returns true, therefore matching everything.
`static <E> Matcher<E>`	`types(java.lang.Class... classes)` Returns a Matcher which reports a match when the given object to match is not null and reports on of the given `classes` as its type.
`static <E> MatcherEditor<E>`	`weakReferenceProxy(MatcherEditor<E> matcherEditor)` Provides a proxy to another MatcherEditor that may go out of scope without explicitly removing itself from the source MatcherEditor's set of listeners.

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

- Method Detail
  - weakReferenceProxy
```
public static <E> MatcherEditor<E> weakReferenceProxy(MatcherEditor<E> matcherEditor)
```
    Provides a proxy to another MatcherEditor that may go out of scope without explicitly removing itself from the source MatcherEditor's set of listeners.
    
    This exists to solve a garbage collection problem. Suppose I have a MatcherEditor M which is long lived and many MatcherEditor.Listeners, t which must listen to M while they exist. Instead of adding each of the t directly as listeners of M, add a proxy instead. The proxy will retain a WeakReference to the t, and will remove itself from the list of listeners for M.
    The MatcherEditor returned by this method makes implementing the above scheme trivial. It does two things for you automatically:
    1. It wraps each MatcherEditor.Listener passed to MatcherEditor.addMatcherEditorListener(ca.odell.glazedlists.matchers.MatcherEditor.Listener<E>) in a WeakReference so that the listeners are garbage collected when they become unreachable.
    2. It registers itself as a weak listener of the given matcherEditor so the MatcherEditor returned by this method will be garbage collected when it becomes unreachable.
    See Also:
    
    WeakReference
  - trueMatcher
```
public static <E> Matcher<E> trueMatcher()
```
    Get a Matcher that always returns true, therefore matching everything.
  - falseMatcher
```
public static <E> Matcher<E> falseMatcher()
```
    Get a Matcher that always returns false, therefore matching nothing..
  - invert
```
public static <E> Matcher<E> invert(Matcher<E> original)
```
    Get a Matcher that returns the opposite of the specified Matcher.
  - isNull
```
public static <E> Matcher<E> isNull()
```
    Get a Matcher that returns returns true iff it is given a non-null object.
  - isNotNull
```
public static <E> Matcher<E> isNotNull()
```
    Get a Matcher that returns returns true iff it is given a null object.
  - nonNullAndNonEmptyString
```
public static Matcher<java.lang.String> nonNullAndNonEmptyString()
```
    Get a Matcher that returns true iff it is given a non-null and non-empty String.
  - beanPropertyMatcher
```
public static <E> Matcher<E> beanPropertyMatcher(java.lang.Class<E> beanClass,
                                                 java.lang.String propertyName,
                                                 java.lang.Object expectedValue)
```
    Creates a Matcher that uses Reflection to compare the expectedValue of the specified property of an object to the expectedValue.
  - rangeMatcher
```
public static <D extends java.lang.Comparable,E> Matcher<E> rangeMatcher(D start,
                                                                         D end)
```
    Creates a Matcher that matches Comparable objects for containment within the range between the given start and end.
  - rangeMatcher
```
public static <D extends java.lang.Comparable,E> Matcher<E> rangeMatcher(D start,
                                                                         D end,
                                                                         Filterator<D,E> filterator)
```
    Creates a Matcher that uses the given filterator to extract Comparable objects from filtered objects and compares those Comparables against the range between the given start and end. If at least one Comparable returned by the filterator is within the range, the object is considered a match.
    
    null start or end values are allowed and are interpreted as "no start" or "no end" to the range respectively.
    
    Parameters:
    
    start - the Comparable which starts the range
    
    end - the Comparable which ends the range
    
    filterator - the logic for extracting filter Comparables from filtered objects
  - propertyEventNameMatcher
```
public static Matcher<java.beans.PropertyChangeEvent> propertyEventNameMatcher(boolean matchPropertyNames,
                                                                               java.lang.String... propertyNames)
```
    Create a Matcher that uses the given propertyNames to match PropertyChangeEvents by their property name. The concrete behaviour depends on the matchPropertyNames parameter. If you want to match property change events against a known set of property names, use a value of true. Alternatively, when you specify false, the specified property names will serve as an exclude list, e.g. if an event matches a specified property name, it will be filtered out.
    
    These matchers are especially useful as an event matcher in a bean connector.
    
    Parameters:
    
    matchPropertyNames - if true, match property change events against the specified property names, if false filter them
    
    propertyNames - the property names to consider
    
    See Also:
    
    GlazedLists.beanConnector(Class, Matcher)
  - count
```
public static <E> int count(java.util.Collection<E> collection,
                            Matcher<? super E> matcher)
```
    Iterate through the specified collection and count all elements that match the specified matcher.
    
    Returns:
    
    the number of elements in the collection that are matched
  - filter
```
public static <E> boolean filter(java.util.Collection<E> collection,
                                 Matcher<? super E> matcher)
```
    Iterate through the specified collection and remove all elements that don't match the specified matcher.
    
    Returns:
    
    true if any elements were removed from the specified Collection
  - select
```
public static <E> E[] select(E[] items,
                             Matcher<? super E> matcher)
```
    Return a new array containing only the items that satisfy the matcher.
    
    Parameters:
    
    items - the array of Objects to search
    
    matcher - the criteria for considering an element a match
    
    Returns:
    
    a new array containing only the items that satisfy the matcher
  - select
```
public static <E> java.util.Collection<? super E> select(java.util.Collection<E> collection,
                                                         Matcher<? super E> matcher)
```
    Add all elements from the given collection that satisfy the matcher to a new ArrayList.
    
    Parameters:
    
    collection - the Collection to search
    
    matcher - the criteria for considering an element a match
    
    Returns:
    
    a new ArrayList containing the elements which satisfy the matcher
  - select
```
public static <E> java.util.Collection<? super E> select(java.util.Collection<E> collection,
                                                         Matcher<? super E> matcher,
                                                         java.util.Collection<? super E> results)
```
    Add all elements from the given collection that satisfy the matcher to the given results Collection. results can be any Collection that supports the Collection.add(E) operation.
    
    Parameters:
    
    collection - the Collection to search
    
    matcher - the criteria for considering an element a match
    
    results - the Collection into which matching elements are added
    
    Returns:
    
    the results Collection containing the elements which satisfy the matcher
  - contains
```
public static <E> boolean contains(java.util.Collection<E> collection,
                                   Matcher<? super E> matcher)
```
    Returns true if the given collection contains an element that satisfies the given matcher; false otherise.
    
    Parameters:
    
    collection - the Collection to search
    
    matcher - the criteria for considering an element a match
    
    Returns:
    
    true if the given collection contains an element that satisfies the given matcher; false otherise
  - indexOf
```
public static <E> int indexOf(java.util.List<E> list,
                              Matcher<? super E> matcher)
```
    Returns the index of the first element from the given list that satisfies the matcher or -1 if no such element exists.
    
    Parameters:
    
    list - the List to search
    
    matcher - the criteria for considering an element a match
    
    Returns:
    
    the index of the first element from the given list that satisfies the matcher or -1 if no such element exists
  - or
```
public static <E> Matcher<E> or(Matcher<? super E>... matchers)
```
    Returns a Matcher which returns a match when any of the given matchers reports a match.
    
    Parameters:
    
    matchers - the Collection of Matchers to combine with an "or" operator
    
    Returns:
    
    a Matcher that combines the matchers via an "or" operator
  - and
```
public static <E> Matcher<E> and(Matcher<? super E>... matchers)
```
    Returns a Matcher which returns a match when all of the given matchers report a match.
    
    Parameters:
    
    matchers - the Collection of Matchers to combine with an "and" operator
    
    Returns:
    
    a Matcher that combines the matchers via an "and" operator
  - types
```
public static <E> Matcher<E> types(java.lang.Class... classes)
```
    Returns a Matcher which reports a match when the given object to match is not null and reports on of the given classes as its type.
    
    Parameters:
    
    classes - the object types that are matched
    
    Returns:
    
    a Matcher which reports a match when the given object to match is not null and reports on of the given classes as its type

Class Matchers

Method Summary

Methods inherited from class java.lang.Object

Method Detail

weakReferenceProxy

trueMatcher

falseMatcher

invert

isNull

isNotNull

nonNullAndNonEmptyString

beanPropertyMatcher

rangeMatcher

rangeMatcher

propertyEventNameMatcher

count

filter

select

select

select

contains

indexOf

or

and

types