# Package org.apache.commons.collections4.functors

package org.apache.commons.collections4.functors
Implements the `Closure`, `Predicate`, `Transformer` and `Factory` interfaces. These provide simple callbacks for processing with collections.

WARNING: from v4.1 onwards several unsafe classes in this package will not be serializable anymore in order to prevent potential remote code execution exploits.

Classes considered to be unsafe are:

- CloneTransformer
- ForClosure
- InstantiateFactory
- InstantiateTransformer
- InvokerTransformer
- PrototypeFactory$PrototypeCloneFactory
- PrototypeFactory$PrototypeSerializationFactory
- WhileClosure

- Related Packages
  Package
  Description
  org.apache.commons.collections4
  Interfaces and utilities shared across all packages.
- Class
  Description
  AbstractQuantifierPredicate<T>
  Abstract base class for quantification predicates, e.g.
  AllPredicate<T>
  Predicate implementation that returns true if all the predicates return true.
  AndPredicate<T>
  Predicate implementation that returns true if both the predicates return true.
  AnyPredicate<T>
  Predicate implementation that returns true if any of the predicates return true.
  CatchAndRethrowClosure<E>
  `Closure` that catches any checked exception and re-throws it as a `FunctorException` runtime exception.
  ChainedClosure<E>
  Closure implementation that chains the specified closures together.
  ChainedTransformer<T>
  Transformer implementation that chains the specified transformers together.
  CloneTransformer<T>
  Transformer implementation that returns a clone of the input object.
  ClosureTransformer<T>
  Transformer implementation that calls a Closure using the input object and then returns the input.
  ComparatorPredicate<T>
  Predicate that compares the input object with the one stored in the predicate using a comparator.
  ComparatorPredicate.Criterion
  ConstantFactory<T>
  Factory implementation that returns the same constant each time.
  ConstantTransformer<I,O>
  Transformer implementation that returns the same constant each time.
  DefaultEquator<T>
  Default `Equator` implementation.
  EqualPredicate<T>
  Predicate implementation that returns true if the input is the same object as the one stored in this predicate by equals.
  ExceptionClosure<E>
  Closure implementation that always throws an exception.
  ExceptionFactory<T>
  Factory implementation that always throws an exception.
  ExceptionPredicate<T>
  Predicate implementation that always throws an exception.
  ExceptionTransformer<I,O>
  Transformer implementation that always throws an exception.
  FactoryTransformer<I,O>
  Transformer implementation that calls a Factory and returns the result.
  FalsePredicate<T>
  Predicate implementation that always returns false.
  ForClosure<E>
  Closure implementation that calls another closure n times, like a for loop.
  IdentityPredicate<T>
  Predicate implementation that returns true if the input is the same object as the one stored in this predicate.
  IfClosure<E>
  Closure implementation acts as an if statement calling one or other closure based on a predicate.
  IfTransformer<I,O>
  Transformer implementation that will call one of two closures based on whether a predicate evaluates as true or false.
  InstanceofPredicate
  Predicate implementation that returns true if the input is an instanceof the type stored in this predicate.
  InstantiateFactory<T>
  Factory implementation that creates a new object instance by reflection.
  InstantiateTransformer<T>
  Transformer implementation that creates a new object instance by reflection.
  InvokerTransformer<I,O>
  Transformer implementation that creates a new object instance by reflection.
  MapTransformer<I,O>
  Transformer implementation that returns the value held in a specified map using the input parameter as a key.
  NonePredicate<T>
  Predicate implementation that returns true if none of the predicates return true.
  NOPClosure<E>
  Closure implementation that does nothing.
  NOPTransformer<T>
  Transformer implementation that does nothing.
  NotNullPredicate<T>
  Predicate implementation that returns true if the input is not null.
  NotPredicate<T>
  Predicate implementation that returns the opposite of the decorated predicate.
  NullIsExceptionPredicate<T>
  Predicate implementation that throws an exception if the input is null.
  NullIsFalsePredicate<T>
  Predicate implementation that returns false if the input is null.
  NullIsTruePredicate<T>
  Predicate implementation that returns true if the input is null.
  NullPredicate<T>
  Predicate implementation that returns true if the input is null.
  OnePredicate<T>
  Predicate implementation that returns true if only one of the predicates return true.
  OrPredicate<T>
  Predicate implementation that returns true if either of the predicates return true.
  PredicateDecorator<T>
  Defines a predicate that decorates one or more other predicates.
  PredicateTransformer<T>
  Transformer implementation that calls a Predicate using the input object and then returns the result.
  PrototypeFactory
  Factory implementation that creates a new instance each time based on a prototype.
  StringValueTransformer<T>
  Transformer implementation that returns the result of calling `String.valueOf` on the input object.
  SwitchClosure<E>
  Closure implementation calls the closure whose predicate returns true, like a switch statement.
  SwitchTransformer<I,O>
  Transformer implementation calls the transformer whose predicate returns true, like a switch statement.
  TransformedPredicate<T>
  Predicate implementation that transforms the given object before invoking another `Predicate`.
  TransformerClosure<E>
  Closure implementation that calls a Transformer using the input object and ignore the result.
  TransformerPredicate<T>
  Predicate implementation that returns the result of a transformer.
  TruePredicate<T>
  Predicate implementation that always returns true.
  UniquePredicate<T>
  Predicate implementation that returns true the first time an object is passed into the predicate.
  WhileClosure<E>
  Closure implementation that executes a closure repeatedly until a condition is met, like a do-while or while loop.