Annotation Type AutoImplement


  • @Documented
    @Retention(SOURCE)
    @Target(TYPE)
    public @interface AutoImplement
    Class annotation used to provide default dummy methods for a class extending an abstract super class or implementing one or more interfaces.

    Example usage:

     import groovy.transform.AutoImplement
    
     @AutoImplement
     class EmptyStringIterator implements Iterator {
         boolean hasNext() { false }
     }
    
     assert !new EmptyStringIterator().hasNext()
     
    In the above example, since hasNext returns false, the next method should never be called, so any dummy implementation would do for next. The "empty" implementation provided by default when using @AutoImplement will suffice - which effectively returns null in Groovy for non-void, non-primitive methods. As a point of interest, the default implementation for methods returning primitive types is to return the default value (which incidentally never satisfies Groovy truth). For boolean this means returning false, so for the above example we could have (albeit perhaps less instructive of our intent) by just using:
     @AutoImplement
     class EmptyStringIterator implements Iterator { }
     
    If we didn't want to assume that callers of our EmptyStringIterator correctly followed the Iterator contract, then we might want to guard against inappropriate calls to next. Rather than just returning null, we might want to throw an exception. This is easily done using the exception annotation attribute as shown below:
     import groovy.transform.AutoImplement
     import static groovy.test.GroovyAssert.shouldFail
    
     @AutoImplement(exception=UnsupportedOperationException)
     class EmptyStringIterator implements Iterator {
         boolean hasNext() { false }
     }
    
     shouldFail(UnsupportedOperationException) {
         new EmptyStringIterator().next()
     }
     
    All implemented methods will throw an instance of this exception constructed using its no-arg constructor. You can also supply a single message annotation attribute in which case the message will be passed as an argument during exception construction as shown in the following example:
     @AutoImplement(exception=UnsupportedOperationException, message='Not supported for this empty iterator')
     class EmptyStringIterator implements Iterator {
         boolean hasNext() { false }
     }
    
     def ex = shouldFail(UnsupportedOperationException) {
         new EmptyStringIterator().next()
     }
     assert ex.message == 'Not supported for this empty iterator'
     
    Finally, you can alternatively supply a code annotation attribute in which case a closure block can be supplied which should contain the code to execute for all implemented methods. This can be seen in the following example:
     @AutoImplement(code = { throw new UnsupportedOperationException("Not supported for ${getClass().simpleName}") })
     class EmptyStringIterator implements Iterator {
         boolean hasNext() { false }
     }
    
     def ex = shouldFail(UnsupportedOperationException) {
         new EmptyStringIterator().next()
     }
     assert ex.message == 'Not supported for EmptyStringIterator'
     
    Since:
    2.5.0
    • Optional Element Summary

      Optional Elements 
      Modifier and Type Optional Element Description
      Class code
      If defined, all unimplemented methods will execute the code found within the supplied closure.
      Class<? extends RuntimeException> exception
      If defined, all unimplemented methods will throw this exception.
      String message
      If exception is defined, message can be used to specify the exception message.
    • Element Detail

      • exception

        Class<? extends RuntimeException> exception
        If defined, all unimplemented methods will throw this exception. Will be ignored if code is defined.
        Default:
        groovy.transform.Undefined.EXCEPTION.class
      • message

        String message
        If exception is defined, message can be used to specify the exception message. Will be ignored if code is defined or exception isn't defined.
        Default:
        "<DummyUndefinedMarkerString-DoNotUse>"
      • code

        Class code
        If defined, all unimplemented methods will execute the code found within the supplied closure.
        Default:
        groovy.transform.Undefined.CLASS.class