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 java.lang.Object
    implements java.util.function.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 Detail

      • IncludeExcludeSet

        public IncludeExcludeSet()
        Default constructor over HashSet
      • IncludeExcludeSet

        public IncludeExcludeSet​(java.lang.Class<SET> setClass)
        Construct an IncludeExclude.
        Type Parameters:
        SET - The type of a 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​(java.util.Set<T> includeSet,
                                 java.util.function.Predicate<P> includePredicate,
                                 java.util.Set<T> excludeSet,
                                 java.util.function.Predicate<P> excludePredicate)
        Construct an IncludeExclude
        Type Parameters:
        SET - The type of a 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 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

        public boolean matches​(P t)
      • test

        public boolean test​(P t)
        Specified by:
        test in interface java.util.function.Predicate<T>
      • isIncludedAndNotExcluded

        public java.lang.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 java.util.Set<T> getIncluded()
      • getExcluded

        public java.util.Set<T> getExcluded()
      • clear

        public void clear()
      • toString

        public java.lang.String toString()
        toString in class java.lang.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
        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
        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