Package org.optaplanner.core.api.function

## Interface PentaPredicate<A,​B,​C,​D,​E>

- Type Parameters:
    `A` - the type of the first argument to the predicate
    `B` - the type of the second argument the predicate
    `C` - the type of the third argument the predicate
    `D` - the type of the fourth argument the predicate
    `E` - the type of the fifth argument the predicate
  Functional Interface:
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

      @FunctionalInterface
      public interface PentaPredicate<A,​B,​C,​D,​E>

  Represents a predicate (boolean-valued function) of five arguments. This is the five-arity specialization of `Predicate`.

  This is a functional interface whose functional method is `test(Object, Object, Object, Object, Object)`.

  See Also:
    `Predicate`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `default PentaPredicate<A,​B,​C,​D,​E>` | `and​(PentaPredicate<? super A,​? super B,​? super C,​? super D,​? super E> other)` | Returns a composed predicate that represents a short-circuiting logical AND of this predicate and another.
    `default PentaPredicate<A,​B,​C,​D,​E>` | `negate()` | Returns a predicate that represents the logical negation of this predicate.
    `default PentaPredicate<A,​B,​C,​D,​E>` | `or​(PentaPredicate<? super A,​? super B,​? super C,​? super D,​? super E> other)` | Returns a composed predicate that represents a short-circuiting logical OR of this predicate and another.
    `boolean` | `test​(A a, B b, C c, D d, E e)` | Evaluates this predicate on the given arguments.

- - ### Method Detail

    - #### test

          boolean test​(A a,
                       B b,
                       C c,
                       D d,
                       E e)

      Evaluates this predicate on the given arguments.
      Parameters:
        `a` - the first input argument
        `b` - the second input argument
        `c` - the third input argument
        `d` - the fourth input argument
        `e` - the fifth input argument
      Returns:
        `true` if the input arguments match the predicate, otherwise `false`

    - #### and

          default PentaPredicate<A,​B,​C,​D,​E> and​(PentaPredicate<? super A,​? super B,​? super C,​? super D,​? super E> other)

      Returns a composed predicate that represents a short-circuiting logical AND of this predicate and another. When evaluating the composed predicate, if this predicate is `false`, then the `other` predicate is not evaluated.

      Any exceptions thrown during evaluation of either predicate are relayed to the caller; if evaluation of this predicate throws an exception, the `other` predicate will not be evaluated.

      Parameters:
        `other` - a predicate that will be logically-ANDed with this predicate
      Returns:
        a composed predicate that represents the short-circuiting logical AND of this predicate and the `other` predicate
      Throws:
        `NullPointerException` - if other is null

    - #### negate

          default PentaPredicate<A,​B,​C,​D,​E> negate()

      Returns a predicate that represents the logical negation of this predicate.
      Returns:
        a predicate that represents the logical negation of this predicate

    - #### or

          default PentaPredicate<A,​B,​C,​D,​E> or​(PentaPredicate<? super A,​? super B,​? super C,​? super D,​? super E> other)

      Returns a composed predicate that represents a short-circuiting logical OR of this predicate and another. When evaluating the composed predicate, if this predicate is `true`, then the `other` predicate is not evaluated.

      Any exceptions thrown during evaluation of either predicate are relayed to the caller; if evaluation of this predicate throws an exception, the `other` predicate will not be evaluated.

      Parameters:
        `other` - a predicate that will be logically-ORed with this predicate
      Returns:
        a composed predicate that represents the short-circuiting logical OR of this predicate and the `other` predicate
      Throws:
        `NullPointerException` - if other is null