com.koloboke.compile

Annotation Type MethodForm

@Retention(value=CLASS)
 @Target(value=METHOD)
public @interface MethodForm

Indicates that the annotated method should be overridden in the Koloboke Compile-generated implementation of the containing type, based on the method form having parameter and return types of the annotated method and name, specified by this annotation. @MethodForm effectively just alters the method form matching algorithm (see description in the specification of @KolobokeMap or @KolobokeSet).

Most commonly this annotation could be used to decorate Koloboke Compile-generated methods, e. g. synchronize them, make extra argument checks, etc. In subclasses, this is as simple as overriding a method and calling super.methodName() in the body, but since the implemented type is a supertype of the Koloboke Compile-generated class, and non-abstract methods in the implemented type underride methods in the generated class, decoration is a little more complicated:

 @KolobokeMap
 public abstract class SynchronizedMap<K, V> {
     public static <K, V> SynchronizedMap<K, V> withExpectedSize(int expectedSize) {
         return new KolobokeSynchronizedMap<K, V>(expectedSize);
     }

     public final synchronized V get(K key) {
         return subGet(key);
     }

     public final synchronized V put(K key, V value) {
         return subPut(key, value);
     }

     public final synchronized int size() {
         return subSize();
     }

     @MethodForm("get")
     abstract V subGet(K key);

     @MethodForm("put")
     abstract V subPut(K key, V value);

     @MethodForm("size")
     abstract int subSize();
 }

Only abstract methods could be annotated with @MethodForm (i. e. they must be implemented by Koloboke Compile, not the user). If several abstract methods in a @KolobokeMap- or @KolobokeSet-annotated type have equivalent parameter types and have same method form name (either specified by @MethodForm or in the absence of this annotation, equal to the method name), Koloboke Compile emits a compilation error message and doesn't generate an implementation for such type.

By default, if there are usages (calls or method references) in the Koloboke Compile-generated implementation class of the method with the name, specified by this @MethodForm annotation, and parameter types of the annotated method, Koloboke Compile replaces usages of this method with the annotated method. If replaceUsages() is false, Koloboke Compile doesn't perform this forwarding, and the implementation methods may call the decorated method implementation.

The annotated method could have any name, but it's own signature (without the @MethodForm annotation) shouldn't match another method form.

Required Element Summary

Required Elements

Modifier and Type	Required Element and Description
String	value The name of the method form, that Koloboke Compile should implement in the overriding method, different from the name of the annotated method.

Optional Element Summary

Optional Elements

Modifier and Type	Optional Element and Description
boolean	replaceUsages Tells whether usages (calls or method references) in the Koloboke Compile-generated implementation class of the method with the name, specified by this @MethodForm annotation, and parameter types of the annotated method, should be replaced with usages of the annotated method or not.

Element Detail

value

public abstract String value

The name of the method form, that Koloboke Compile should implement in the overriding method, different from the name of the annotated method.

Returns:

name of the method form, that Koloboke Compile should implement in the overriding method

replaceUsages

public abstract boolean replaceUsages

Tells whether usages (calls or method references) in the Koloboke Compile-generated implementation class of the method with the name, specified by this @MethodForm annotation, and parameter types of the annotated method, should be replaced with usages of the annotated method or not. Only usages, which statically resolve to the prototype method, i. e. where the type of the method call receiver is the implemented type or the generated implementation type, but not a supertype of the implemented type, are replaced.

If replaceUsages is configured to false and usages are not replaced, the same risks as with usual method underriding appear.

Returns:

true if Koloboke Compile should replace usages of the method form prototype methods in the generated implementation with the @MethodForm-annotated method

Default:

true