groovy.transform

## Annotation Type Memoized

    @Documented
     @Retention(value=SOURCE)
     @Target(value=METHOD)
    public @interface Memoized

Method annotation that creates a cache for the results of the execution of the annotated method. Whenever the method is called, the mapping between the parameters and the return value is preserved in a cache making subsequent calls with the same arguments fast.

Example usage:

     class MemoizedExample {

          @Memoized
         int sum(int n1, int n2) {
             println "$n1 + $n2 = ${n1 + n2}"
             n1 + n2
         }
     }

which becomes (approximately):

     class MemoizedExample {

         private final Closure memoizedSum = { int n1, int n2 ->
             private$method$memoizedSum(n1,n2)
         }.memoize()

         int sum(int n1, int n2) {
             memoizedSum(n1, n2)
         }

         private private$method$memoizedSum(int n1, int n2) {
             println "$n1 + $n2 = ${n1 + n2}"
             n1 + n2
         }
     }

Upon execution of this code:

     def instance = new MemoizedExample()
     println instance.sum(1, 2)
     println instance.sum(1, 2)
     println instance.sum(2, 3)
     println instance.sum(2, 3)

The following will be output:

     1 + 2 = 3
     3
     3
     2 + 3 = 5
     5
     5

More examples:

     import groovy.transform.*

     // Script variable which is changed when increment()
     // method is invoked.
     // If cached method call is invoked then the value
     // of this variable will not change.
     @Field boolean incrementChange = false

     @Memoized
     int increment(int value) {
         incrementChange = true
         value + 1
     }

     // Invoke increment with argument 10.
     increment(10)

     // increment is invoked so incrementChange is true.
     assert incrementChange

     // Set incrementChange back to false.
     incrementChange = false

     // Invoke increment with argument 10.
     increment(10)

     // Now the cached method is used and
     // incrementChange is not changed.
     assert !incrementChange

     // Invoke increment with other argument value.
     increment(11)

     // increment is invoked so incrementChange is true.
     assert incrementChange

Author:
  Andrey Bloschetsov

### Optional Element Summary

Optional Elements
`int` `maxCacheSize` The maximum size the cache can grow to.
`int` `protectedCacheSize` Number of cached return values to protect from garbage collection.

### Element Detail

#### protectedCacheSize

    public abstract int protectedCacheSize

Number of cached return values to protect from garbage collection.

Default:
  0

#### maxCacheSize

    public abstract int maxCacheSize

The maximum size the cache can grow to.

Default:
  0