Class 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:
Direct Known Subclasses:

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

    • include

      public void include(T element)
    • include

      public void include(T... element)
    • exclude

      public void exclude(T element)
    • exclude

      public 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>
      t - the input argument
      true if the input matches an include, and is not excluded.
    • isIncludedAndNotExcluded

      public Boolean isIncludedAndNotExcluded(P item)
      Test Included and not Excluded
      item - The item to test
      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()
      toString in class Object
    • isEmpty

      public boolean isEmpty()