org.eclipse.jetty.util

Class IncludeExcludeSet<P,T>

java.lang.Object

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

Type Parameters:

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

T - The type of the instance passed to the predicate

All Implemented Interfaces:

Predicate<T>

Direct Known Subclasses:

IncludeExclude

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

Utility class to maintain a set of inclusions and exclusions.

Maintains a set of included and excluded elements. The method matches(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<P> includeSet, Predicate<T> includePredicate, Set<P> excludeSet, Predicate<T> excludePredicate) Construct an IncludeExclude

Method Summary

Modifier and Type	Method and Description
void	clear()
void	exclude(P... element)
void	exclude(P element)
Set<P>	getExcluded()
Set<P>	getIncluded()
void	include(P... element)
void	include(P element)
boolean	isEmpty()
boolean	matches(T t)
int	size()
boolean	test(T t)
String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, 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<P> includeSet,
                         Predicate<T> includePredicate,
                         Set<P> excludeSet,
                         Predicate<T> 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(P element)

include

public void include(P... element)

exclude

public void exclude(P element)

exclude

public void exclude(P... element)

matches

public boolean matches(T t)

test

public boolean test(T t)

Specified by:

test in interface Predicate<T>

size

public int size()

getIncluded

public Set<P> getIncluded()

getExcluded

public Set<P> getExcluded()

clear

public void clear()

toString

public String toString()

Overrides:

toString in class Object

isEmpty

public boolean isEmpty()