Package 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 Details

    • IncludeExcludeSet

      public IncludeExcludeSet()
      Default constructor over HashSet

    • IncludeExcludeSet

      public IncludeExcludeSet(Class<SET> setClass)
      Construct an IncludeExclude.
      Type Parameters:
      SET - The type of 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 IncludeExcludeSet.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 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 Details

    • asImmutable

      public IncludeExcludeSet<T,P> asImmutable()

    • include

      public void include(T element)

    • include

      @SafeVarargs public final void include(T... element)

    • exclude

      public void exclude(T element)

    • exclude

      @SafeVarargs public final void exclude(T... element)

    • test

      public boolean test(P t)
      Test includes and excludes for match.

      Excludes always win over includes.

      Empty includes means all inputs are allowed.

      Specified by:
      test in interface Predicate<T>
      Parameters:
      t - the input argument
      Returns:
      true if the input matches an include, and is not excluded.

    • 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()