org.springframework.util

## Class InstanceFilter<T>

- java.lang.Object
- - org.springframework.util.InstanceFilter<T>

- Type Parameters:
    `T` - the instance type
  Direct Known Subclasses:
    ExceptionTypeFilter

      public class InstanceFilter<T>
      extends Object

  A simple instance filter that checks if a given instance match based on a collection of includes and excludes element.

  Subclasses may want to override `match(Object, Object)` to provide a custom matching algorithm.

  Since:
    4.1
  Author:
    Stephane Nicoll

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `InstanceFilter(Collection<? extends T> includes, Collection<? extends T> excludes, boolean matchIfEmpty)` Create a new instance based on includes/excludes collections.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `match(T instance)` Determine if the specified `instance` matches this filter.
    `protected boolean` | `match(T instance, Collection<? extends T> candidates)` Determine if the specified `instance` matches one of the candidates.
    `protected boolean` | `match(T instance, T candidate)` Determine if the specified `instance` is equal to the specified `candidate`.
    `String` | `toString()`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### InstanceFilter

          public InstanceFilter(@Nullable
                                Collection<? extends T> includes,
                                @Nullable
                                Collection<? extends T> excludes,
                                boolean matchIfEmpty)

      Create a new instance based on includes/excludes collections.

      A particular element will match if it "matches" the one of the element in the includes list and does not match one of the element in the excludes list.

      Subclasses may redefine what matching means. By default, an element match with another if it is equals according to `Object.equals(Object)`

      If both collections are empty, `matchIfEmpty` defines if an element matches or not.

      Parameters:
        `includes` - the collection of includes
        `excludes` - the collection of excludes
        `matchIfEmpty` - the matching result if both the includes and the excludes collections are empty

  - ### Method Detail

    - #### match

          public boolean match(T instance)

      Determine if the specified `instance` matches this filter.

    - #### match

          protected boolean match(T instance,
                                  T candidate)

      Determine if the specified `instance` is equal to the specified `candidate`.
      Parameters:
        `instance` - the instance to handle
        `candidate` - a candidate defined by this filter
      Returns:
        `true` if the instance matches the candidate

    - #### match

          protected boolean match(T instance,
                                  Collection<? extends T> candidates)

      Determine if the specified `instance` matches one of the candidates.

      If the candidates collection is `null`, returns `false`.

      Parameters:
        `instance` - the instance to check
        `candidates` - a list of candidates
      Returns:
        `true` if the instance match or the candidates collection is null

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`