|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.levigo.util.base.glazedlists.matchers.Matchers
public final class Matchers
A factory for creating Matchers.
Method Summary | ||
---|---|---|
static
|
and(Matcher<? super E>... matchers)
Returns a Matcher which returns a match when all of the given matchers report a match. |
|
static
|
beanPropertyMatcher(Class<E> beanClass,
String propertyName,
Object expectedValue)
Creates a Matcher that uses Reflection to compare the expectedValue
of the specified property of an object to the expectedValue . |
|
static
|
contains(Collection<E> collection,
Matcher<? super E> matcher)
Returns true if the given collection contains an
element that satisfies the given matcher ; false
otherise. |
|
static
|
count(Collection<E> collection,
Matcher<? super E> matcher)
Iterate through the specified collection and count all elements that match the specified matcher. |
|
static
|
falseMatcher()
Get a Matcher that always returns false, therefore matching nothing.. |
|
static
|
filter(Collection<E> collection,
Matcher<? super E> matcher)
Iterate through the specified collection and remove all elements that don't match the specified matcher. |
|
static
|
indexOf(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
|
invert(Matcher<E> original)
Get a Matcher that returns the opposite of the specified Matcher . |
|
static
|
isNotNull()
Get a Matcher that returns returns true iff it is
given a null object. |
|
static
|
isNull()
Get a Matcher that returns returns true iff it is
given a non-null object. |
|
static Matcher<String> |
nonNullAndNonEmptyString()
Get a Matcher that returns true iff it is given a
non-null and non-empty String. |
|
static
|
or(Matcher<? super E>... matchers)
Returns a Matcher which returns a match when any of the given matchers reports a match. |
|
static Matcher<PropertyChangeEvent> |
propertyEventNameMatcher(boolean matchPropertyNames,
String... propertyNames)
Create a Matcher that uses the given propertyNames to match
PropertyChangeEvent s by their property name. |
|
static
|
rangeMatcher(D start,
D end)
Creates a Matcher that matches Comparable objects for
containment within the range between the given start
and end . |
|
static
|
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
|
select(Collection<E> collection,
Matcher<? super E> matcher)
Add all elements from the given collection that satisfy the
matcher to a new ArrayList . |
|
static
|
select(Collection<E> collection,
Matcher<? super E> matcher,
Collection<? super E> results)
Add all elements from the given collection that satisfy the
matcher to the given results Collection. |
|
static
|
select(E[] items,
Matcher<? super E> matcher)
Return a new array containing only the items that satisfy
the matcher . |
|
static
|
trueMatcher()
Get a Matcher that always returns true, therefore matching everything. |
|
static
|
types(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
|
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 |
---|
public static <E> MatcherEditor<E> weakReferenceProxy(MatcherEditor<E> matcherEditor)
This exists to solve a garbage collection problem. Suppose I have a
MatcherEditor
M which is long lived and many
MatcherEditor.Listener
s, 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:
MatcherEditor.Listener
passed to
MatcherEditor.addMatcherEditorListener(com.levigo.util.base.glazedlists.matchers.MatcherEditor.Listener)
in a
WeakReference
so that the listeners are
garbage collected when they become unreachable.
matcherEditor
so the MatcherEditor returned by
this method will be garbage collected when it becomes unreachable.
WeakReference
public static <E> Matcher<E> trueMatcher()
Matcher
that always returns true, therefore matching everything.
public static <E> Matcher<E> falseMatcher()
Matcher
that always returns false, therefore matching nothing..
public static <E> Matcher<E> invert(Matcher<E> original)
Matcher
that returns the opposite of the specified Matcher
.
public static <E> Matcher<E> isNull()
Matcher
that returns returns true iff it is
given a non-null
object.
public static <E> Matcher<E> isNotNull()
Matcher
that returns returns true iff it is
given a null
object.
public static Matcher<String> nonNullAndNonEmptyString()
Matcher
that returns true iff it is given a
non-null
and non-empty
String.
public static <E> Matcher<E> beanPropertyMatcher(Class<E> beanClass, String propertyName, Object expectedValue)
Matcher
that uses Reflection to compare the expectedValue
of the specified property of an object to the expectedValue
.
public static <D extends Comparable,E> Matcher<E> rangeMatcher(D start, D end)
Matcher
that matches Comparable
objects for
containment within the range between the given start
and end
.
public static <D extends Comparable,E> Matcher<E> rangeMatcher(D start, D end, Filterator<D,E> filterator)
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.
start
- the Comparable
which starts the rangeend
- the Comparable
which ends the rangefilterator
- the logic for extracting filter Comparable
s
from filtered objectspublic static Matcher<PropertyChangeEvent> propertyEventNameMatcher(boolean matchPropertyNames, String... propertyNames)
Matcher
that uses the given propertyNames
to match
PropertyChangeEvent
s 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.
matchPropertyNames
- if true
, match property change events against the
specified property names, if false
filter thempropertyNames
- the property names to considerGlazedLists.beanConnector(Class, Matcher)
public static <E> int count(Collection<E> collection, Matcher<? super E> matcher)
public static <E> boolean filter(Collection<E> collection, Matcher<? super E> matcher)
true
if any elements were removed from the specified
Collection
public static <E> E[] select(E[] items, Matcher<? super E> matcher)
items
that satisfy
the matcher
.
items
- the array of Objects to searchmatcher
- the criteria for considering an element a match
items
that satisfy
the matcher
public static <E> Collection<? super E> select(Collection<E> collection, Matcher<? super E> matcher)
collection
that satisfy the
matcher
to a new ArrayList
.
collection
- the Collection to searchmatcher
- the criteria for considering an element a match
ArrayList
containing the elements which satisfy
the matcher
public static <E> Collection<? super E> select(Collection<E> collection, Matcher<? super E> matcher, Collection<? super E> results)
collection
that satisfy the
matcher
to the given results
Collection.
results
can be any Collection that supports the
Collection.add(E)
operation.
collection
- the Collection to searchmatcher
- the criteria for considering an element a matchresults
- the Collection into which matching elements are added
results
Collection
containing the
elements which satisfy the matcher
public static <E> boolean contains(Collection<E> collection, Matcher<? super E> matcher)
collection
contains an
element that satisfies the given matcher
; false
otherise.
collection
- the Collection to searchmatcher
- the criteria for considering an element a match
collection
contains an
element that satisfies the given matcher
;
false otherisepublic static <E> int indexOf(List<E> list, Matcher<? super E> matcher)
list
that satisfies the matcher
or -1 if no such
element exists.
list
- the List to searchmatcher
- the criteria for considering an element a match
list
that satisfies the matcher
or -1 if no such
element existspublic static <E> Matcher<E> or(Matcher<? super E>... matchers)
matchers
reports a match.
matchers
- the Collection of Matchers to combine with an "or" operator
matchers
via an "or" operatorpublic static <E> Matcher<E> and(Matcher<? super E>... matchers)
matchers
report a match.
matchers
- the Collection of Matchers to combine with an "and" operator
matchers
via an "and" operatorpublic static <E> Matcher<E> types(Class... classes)
classes
as its type.
classes
- the object types that are matched
classes
as its
type
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |