Memoizer (Apache Commons Lang 3.17.0 API)
Description: declaration: package: org.apache.commons.lang3.concurrent, class: Memoizer

Package org.apache.commons.lang3.concurrent

# Class Memoizer<I,O>

java.lang.Object
org.apache.commons.lang3.concurrent.Memoizer<I,O>

Type Parameters:
  `I` - the type of the input to the calculation
  `O` - the type of the output of the calculation

All Implemented Interfaces:
  `Computable<I,O>`

public class Memoizer<I,O> extends Object implements Computable<I,O>
Definition of an interface for a wrapper around a calculation that takes a single parameter and returns a result. The results for the calculation will be cached for future requests.

This is not a fully functional cache, there is no way of limiting or removing results once they have been generated. However, it is possible to get the implementation to regenerate the result for a given parameter, if an error was thrown during the previous calculation, by setting the option during the construction of the class. If this is not set the class will return the cached exception.

Thanks go to Brian Goetz, Tim Peierls and the members of JCP JSR-166 Expert Group for coming up with the original implementation of the class. It was also published within Java Concurrency in Practice as a sample.

Since:
  3.6

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `Memoizer(Function<I,O> function)`
  Constructs a Memoizer for the provided Function calculation.
  `Memoizer(Function<I,O> function, boolean recalculate)`
  Constructs a Memoizer for the provided Function calculation, with the option of whether a Function that experiences an error should recalculate on subsequent calls or return the same cached exception.
  `Memoizer(Computable<I,O> computable)`
  Constructs a Memoizer for the provided Computable calculation.
  `Memoizer(Computable<I,O> computable, boolean recalculate)`
  Constructs a Memoizer for the provided Computable calculation, with the option of whether a Computation that experiences an error should recalculate on subsequent calls or return the same cached exception.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `O`
  `compute(I arg)`
  This method will return the result of the calculation and cache it, if it has not previously been calculated.

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

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

- ## Constructor Details

  - ### Memoizer

    public Memoizer(Computable<I,O> computable)
    Constructs a Memoizer for the provided Computable calculation.

    If a calculation throws an exception for any reason, this exception will be cached and returned for all future calls with the provided parameter.

    Parameters:
      `computable` - the computation whose results should be memorized

  - ### Memoizer

    public Memoizer(Computable<I,O> computable, boolean recalculate)
    Constructs a Memoizer for the provided Computable calculation, with the option of whether a Computation that experiences an error should recalculate on subsequent calls or return the same cached exception.
    Parameters:
      `computable` - the computation whose results should be memorized
      `recalculate` - determines whether the computation should be recalculated on subsequent calls if the previous call failed

  - ### Memoizer

    public Memoizer(Function<I,O> function)
    Constructs a Memoizer for the provided Function calculation.

    If a calculation throws an exception for any reason, this exception will be cached and returned for all future calls with the provided parameter.

    Parameters:
      `function` - the function whose results should be memorized
    Since:
      2.13.0

  - ### Memoizer

    public Memoizer(Function<I,O> function, boolean recalculate)
    Constructs a Memoizer for the provided Function calculation, with the option of whether a Function that experiences an error should recalculate on subsequent calls or return the same cached exception.
    Parameters:
      `function` - the computation whose results should be memorized
      `recalculate` - determines whether the computation should be recalculated on subsequent calls if the previous call failed
    Since:
      2.13.0

- ## Method Details

  - ### compute

    public O compute(I arg) throws InterruptedException
    This method will return the result of the calculation and cache it, if it has not previously been calculated.

    This cache will also cache exceptions that occur during the computation if the `recalculate` parameter in the constructor was set to `false`, or not set. Otherwise, if an exception happened on the previous calculation, the method will attempt again to generate a value.

    Specified by:
      `compute` in interface `Computable<I,O>`
    Parameters:
      `arg` - the argument for the calculation
    Returns:
      the result of the calculation
    Throws:
      `InterruptedException` - thrown if the calculation is interrupted