org.eclipse.jetty.util

Class IncludeExcludeSet<T,P>

java.lang.Object

org.eclipse.jetty.util.IncludeExcludeSet<T,P>

Type Parameters:

T - The type of element of the set (often a pattern)

P - The type of the instance passed to the predicate

All Implemented Interfaces:

Predicate<P>

Direct Known Subclasses:

IncludeExclude

public class IncludeExcludeSet<T,P>
extends Object
implements Predicate<P>

Utility class to maintain a set of inclusions and exclusions.

Maintains a set of included and excluded elements. The method test(Object) will return true IFF the passed object is not in the excluded set AND ( either the included set is empty OR the object is in the included set)

The type of the underlying Set used may be passed into the constructor, so special sets like Servlet PathMap may be used.

Constructor Summary

Constructors

Constructor and Description
IncludeExcludeSet() Default constructor over HashSet
IncludeExcludeSet(Class<SET> setClass) Construct an IncludeExclude.
IncludeExcludeSet(Set<T> includeSet, Predicate<P> includePredicate, Set<T> excludeSet, Predicate<P> excludePredicate) Construct an IncludeExclude

Method Summary

Modifier and Type	Method and Description
void	clear()
void	exclude(T... element)
void	exclude(T element)
Set<T>	getExcluded()
Set<T>	getIncluded()
boolean	hasExcludes()
boolean	hasIncludes()
void	include(T... element)
void	include(T element)
boolean	isEmpty()
Boolean	isIncludedAndNotExcluded(P item) Test Included and not Excluded
static <T1,T2> boolean	matchCombined(T1 item1, IncludeExcludeSet<?,T1> set1, T2 item2, IncludeExcludeSet<?,T2> set2) Match items in combined IncludeExcludeSets.
boolean	matches(P t) Deprecated.
int	size()
boolean	test(P t)
String	toString()

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.function.Predicate

and, isEqual, negate, or

Constructor Detail

IncludeExcludeSet

public IncludeExcludeSet()

Default constructor over HashSet

IncludeExcludeSet

public IncludeExcludeSet(Class<SET> setClass)

Construct an IncludeExclude.

Type Parameters:

SET - The type of a set to use as the backing store

Parameters:

setClass - The type of Set to using internally to hold patterns. Two instances will be created. one for include patterns and one for exclude patters. If the class is also a Predicate, then it is also used as the item test for the set, otherwise a SetContainsPredicate instance is created.

IncludeExcludeSet

public IncludeExcludeSet(Set<T> includeSet,
                         Predicate<P> includePredicate,
                         Set<T> excludeSet,
                         Predicate<P> excludePredicate)

Construct an IncludeExclude

Type Parameters:

SET - The type of a set to use as the backing store

Parameters:

includeSet - the Set of items that represent the included space

includePredicate - the Predicate for included item testing (null for simple Set.contains(Object) test)

excludeSet - the Set of items that represent the excluded space

excludePredicate - the Predicate for excluded item testing (null for simple Set.contains(Object) test)

Method Detail

include

public void include(T element)

include

public void include(T... element)

exclude

public void exclude(T element)

exclude

public void exclude(T... element)

matches

@Deprecated
public boolean matches(P t)

Deprecated.

test

public boolean test(P t)

Specified by:

test in interface Predicate<P>

isIncludedAndNotExcluded

public Boolean isIncludedAndNotExcluded(P item)

Test Included and not Excluded

Parameters:

item - The item to test

Returns:

Boolean.TRUE if item is included, Boolean.FALSE if item is excluded or null if neither

hasIncludes

public boolean hasIncludes()

hasExcludes

public boolean hasExcludes()

size

public int size()

getIncluded

public Set<T> getIncluded()

getExcluded

public Set<T> getExcluded()

clear

public void clear()

toString

public String toString()

Overrides:

toString in class Object

isEmpty

public boolean isEmpty()

matchCombined

public static <T1,T2> boolean matchCombined(T1 item1,
                                            IncludeExcludeSet<?,T1> set1,
                                            T2 item2,
                                            IncludeExcludeSet<?,T2> set2)

Match items in combined IncludeExcludeSets.

Type Parameters:

T1 - The type of item1

T2 - The type of item2

Parameters:

item1 - The item to match against set1

set1 - A IncludeExcludeSet to match item1 against

item2 - The item to match against set2

set2 - A IncludeExcludeSet to match item2 against

Returns:

True IFF

• Neither item is excluded from their respective sets
• Both sets have no includes OR at least one of the items is included in its respective set