com.stvconsultants.easygloss
Class AbstractGloss

java.lang.Object
  com.stvconsultants.easygloss.AbstractGloss

Direct Known Subclasses:

JavaEEGloss, MultiGloss, StandardBooleanGloss, StandardByteGloss, StandardCharGloss, StandardDoubleGloss, StandardFloatGloss, StandardGloss, StandardIntGloss, StandardLongGloss, StandardShortGloss

public abstract class AbstractGloss
extends java.lang.Object

AbstractGloss is the base class for all glosses.

Author:

Stephen Connolly

Constructor Summary

protected

AbstractGloss() Creates a new instance of AbstractGloss

Method Summary

static void	apply(java.lang.annotation.Annotation annotation, java.lang.Object instance, boolean injection) Apply the specified gloss to the instance.
static void	apply(java.lang.annotation.Annotation annotation, java.lang.Object instance, byte injection) Apply the specified gloss to the instance.
static void	apply(java.lang.annotation.Annotation annotation, java.lang.Object instance, char injection) Apply the specified gloss to the instance.
static void	apply(java.lang.annotation.Annotation annotation, java.lang.Object instance, double injection) Apply the specified gloss to the instance.
static void	apply(java.lang.annotation.Annotation annotation, java.lang.Object instance, float injection) Apply the specified gloss to the instance.
static void	apply(java.lang.annotation.Annotation annotation, java.lang.Object instance, int injection) Apply the specified gloss to the instance.
static void	apply(java.lang.annotation.Annotation annotation, java.lang.Object instance, long injection) Apply the specified gloss to the instance.
static void	apply(java.lang.annotation.Annotation annotation, java.lang.Object instance, java.lang.Object injection) Apply the specified gloss to the instance.
static void	apply(java.lang.annotation.Annotation annotation, java.lang.Object instance, short injection) Apply the specified gloss to the instance.
static void	apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, boolean injection) Apply the specified gloss to the instance.
static void	apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, byte injection) Apply the specified gloss to the instance.
static void	apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, char injection) Apply the specified gloss to the instance.
static void	apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, double injection) Apply the specified gloss to the instance.
static void	apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, float injection) Apply the specified gloss to the instance.
static void	apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, int injection) Apply the specified gloss to the instance.
static void	apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, long injection) Apply the specified gloss to the instance.
static void	apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, java.lang.Object injection) Apply the specified gloss to the instance.
static void	apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, short injection) Apply the specified gloss to the instance.
static void	apply(Footnote annotation, java.lang.Object instance, boolean injection) Apply the specified gloss to the instance.
static void	apply(Footnote annotation, java.lang.Object instance, byte injection) Apply the specified gloss to the instance.
static void	apply(Footnote annotation, java.lang.Object instance, char injection) Apply the specified gloss to the instance.
static void	apply(Footnote annotation, java.lang.Object instance, double injection) Apply the specified gloss to the instance.
static void	apply(Footnote annotation, java.lang.Object instance, float injection) Apply the specified gloss to the instance.
static void	apply(Footnote annotation, java.lang.Object instance, int injection) Apply the specified gloss to the instance.
static void	apply(Footnote annotation, java.lang.Object instance, long injection) Apply the specified gloss to the instance.
static void	apply(Footnote annotation, java.lang.Object instance, java.lang.Object injection) Apply the specified gloss to the instance.
static void	apply(Footnote annotation, java.lang.Object instance, short injection) Apply the specified gloss to the instance.
abstract void	apply(java.lang.Object instance) Apply the gloss to the instance
static void	applyStatic(java.lang.annotation.Annotation annotation, java.lang.Class instanceClass, boolean injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.annotation.Annotation annotation, java.lang.Class instanceClass, byte injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.annotation.Annotation annotation, java.lang.Class instanceClass, char injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.annotation.Annotation annotation, java.lang.Class instanceClass, double injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.annotation.Annotation annotation, java.lang.Class instanceClass, float injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.annotation.Annotation annotation, java.lang.Class instanceClass, int injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.annotation.Annotation annotation, java.lang.Class instanceClass, long injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.annotation.Annotation annotation, java.lang.Class instanceClass, java.lang.Object injection) Apply the specified gloss to the static class.
static void	applyStatic(java.lang.annotation.Annotation annotation, java.lang.Class instanceClass, short injection) Apply the specified gloss to the instance.
abstract void	applyStatic(java.lang.Class instanceClass) Apply the gloss to the class
static void	applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class instanceClass, boolean injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class instanceClass, byte injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class instanceClass, char injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class instanceClass, double injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class instanceClass, float injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class instanceClass, int injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class instanceClass, long injection) Apply the specified gloss to the instance.
static void	applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class instanceClass, java.lang.Object injection) Apply the specified gloss to the static class.
static void	applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Class instanceClass, short injection) Apply the specified gloss to the instance.
static void	applyStatic(Footnote annotation, java.lang.Class instanceClass, boolean injection) Apply the specified gloss to the instance.
static void	applyStatic(Footnote annotation, java.lang.Class instanceClass, byte injection) Apply the specified gloss to the instance.
static void	applyStatic(Footnote annotation, java.lang.Class instanceClass, char injection) Apply the specified gloss to the instance.
static void	applyStatic(Footnote annotation, java.lang.Class instanceClass, double injection) Apply the specified gloss to the instance.
static void	applyStatic(Footnote annotation, java.lang.Class instanceClass, float injection) Apply the specified gloss to the instance.
static void	applyStatic(Footnote annotation, java.lang.Class instanceClass, int injection) Apply the specified gloss to the instance.
static void	applyStatic(Footnote annotation, java.lang.Class instanceClass, long injection) Apply the specified gloss to the instance.
static void	applyStatic(Footnote annotation, java.lang.Class instanceClass, java.lang.Object injection) Apply the specified gloss to the static class.
static void	applyStatic(Footnote annotation, java.lang.Class instanceClass, short injection) Apply the specified gloss to the instance.
protected static java.util.List<java.lang.reflect.Field>	filter(java.util.List<java.lang.reflect.Field> list, java.lang.Class type) Filter a list of fields, returning a list of only those that are assignment compatible with type.
protected static java.util.List<java.lang.reflect.Method>	filter(java.util.List<java.lang.reflect.Method> list, java.lang.Class returnType, java.lang.Class[] paramTypes) Filter a list of methods, returning a list of only those that match the method signature.
protected static java.util.List<java.lang.reflect.Method>	filterGetters(java.util.List<java.lang.reflect.Method> list, java.lang.Class type) Filter a list of methods, returning a list of only those that are getters for type type.
protected static java.util.List<java.lang.reflect.Method>	filterSetters(java.util.List<java.lang.reflect.Method> list, java.lang.Class type) Filter a list of methods, returning a list of only those that are setters for type type.
protected static java.util.List<java.lang.reflect.Field>	findFields(java.lang.Class clazz, Footnote annotation) Get all the annotated fields for the class clazz including those from the superclasses.
protected static java.util.List<java.lang.reflect.Method>	findMethods(java.lang.Class clazz, Footnote annotation) Get all the annotated methods for the class clazz including those from the superclasses.
protected static java.lang.reflect.Method	findSetter(java.lang.Class clazz, java.lang.reflect.Method getter) Find the setter for the corresponding getter in the specified class.
static void	invoke(java.lang.annotation.Annotation annotation, java.lang.Object instance, java.lang.Object... params) Call all the matching annotated methods in the instance using the parameters specified.
static void	invoke(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType, java.lang.Object instance, java.lang.Object... params) Call all the matching annotated methods in the instance using the parameters specified.
static void	invoke(Footnote annotation, java.lang.Object instance, java.lang.Object... params) Call all the matching annotated methods in the instance using the parameters specified.
protected static boolean	matchParameters(java.lang.reflect.Method method, java.lang.Class<?>[] paramTypes) Check if the method's parameters match paramTypes.

Methods inherited from class java.lang.Object

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

Constructor Detail

AbstractGloss

protected AbstractGloss()

Creates a new instance of AbstractGloss

Method Detail

applyStatic

public static void applyStatic(Footnote annotation,
                               java.lang.Class instanceClass,
                               java.lang.Object injection)

Apply the specified gloss to the static class. Tries to inject any annotated static fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instance to search

injection - The value to inject

Since:

1.2

applyStatic

public static void applyStatic(java.lang.annotation.Annotation annotation,
                               java.lang.Class instanceClass,
                               java.lang.Object injection)

Apply the specified gloss to the static class. Tries to inject any annotated static fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instance to search

injection - The value to inject

Since:

1.2

applyStatic

public static void applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                               java.lang.Class instanceClass,
                               java.lang.Object injection)

Apply the specified gloss to the static class. Tries to inject any annotated static fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instanceClass - The instance to search

injection - The value to inject

Since:

1.2

apply

public static void apply(Footnote annotation,
                         java.lang.Object instance,
                         java.lang.Object injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

apply

public static void apply(java.lang.annotation.Annotation annotation,
                         java.lang.Object instance,
                         java.lang.Object injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                         java.lang.Object instance,
                         java.lang.Object injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(Footnote annotation,
                         java.lang.Object instance,
                         int injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

apply

public static void apply(java.lang.annotation.Annotation annotation,
                         java.lang.Object instance,
                         int injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                         java.lang.Object instance,
                         int injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(Footnote annotation,
                         java.lang.Object instance,
                         short injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

apply

public static void apply(java.lang.annotation.Annotation annotation,
                         java.lang.Object instance,
                         short injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                         java.lang.Object instance,
                         short injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(Footnote annotation,
                         java.lang.Object instance,
                         long injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

apply

public static void apply(java.lang.annotation.Annotation annotation,
                         java.lang.Object instance,
                         long injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                         java.lang.Object instance,
                         long injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(Footnote annotation,
                         java.lang.Object instance,
                         float injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

apply

public static void apply(java.lang.annotation.Annotation annotation,
                         java.lang.Object instance,
                         float injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                         java.lang.Object instance,
                         float injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(Footnote annotation,
                         java.lang.Object instance,
                         double injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

apply

public static void apply(java.lang.annotation.Annotation annotation,
                         java.lang.Object instance,
                         double injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                         java.lang.Object instance,
                         double injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(Footnote annotation,
                         java.lang.Object instance,
                         char injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

apply

public static void apply(java.lang.annotation.Annotation annotation,
                         java.lang.Object instance,
                         char injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                         java.lang.Object instance,
                         char injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(Footnote annotation,
                         java.lang.Object instance,
                         byte injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

apply

public static void apply(java.lang.annotation.Annotation annotation,
                         java.lang.Object instance,
                         byte injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                         java.lang.Object instance,
                         byte injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(Footnote annotation,
                         java.lang.Object instance,
                         boolean injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

apply

public static void apply(java.lang.annotation.Annotation annotation,
                         java.lang.Object instance,
                         boolean injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instance - The instance to search

injection - The value to inject

Since:

1.1

apply

public static void apply(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                         java.lang.Object instance,
                         boolean injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instance - The instance to search

injection - The value to inject

Since:

1.1

filter

protected static java.util.List<java.lang.reflect.Field> filter(java.util.List<java.lang.reflect.Field> list,
                                                                java.lang.Class type)

Filter a list of fields, returning a list of only those that are assignment compatible with type.

Parameters:

list - The list of fields to filter.

type - The type that the fields must be assignment compatible with.

Returns:

The filtered list.

filter

protected static java.util.List<java.lang.reflect.Method> filter(java.util.List<java.lang.reflect.Method> list,
                                                                 java.lang.Class returnType,
                                                                 java.lang.Class[] paramTypes)

Filter a list of methods, returning a list of only those that match the method signature.

Parameters:

list - The list of methods to filter.

returnType - The return type of the method signature.

paramTypes - The parameters of the method signature.

Returns:

The filtered list.

filterGetters

protected static java.util.List<java.lang.reflect.Method> filterGetters(java.util.List<java.lang.reflect.Method> list,
                                                                        java.lang.Class type)

Filter a list of methods, returning a list of only those that are getters for type type.

Parameters:

list - The list of methods to filter.

type - The type of getter to filter on.

Returns:

The filtered list.

filterSetters

protected static java.util.List<java.lang.reflect.Method> filterSetters(java.util.List<java.lang.reflect.Method> list,
                                                                        java.lang.Class type)

Filter a list of methods, returning a list of only those that are setters for type type.

Parameters:

list - The list of methods to filter.

type - The type of getter to filter on.

Returns:

The filtered list.

findFields

protected static java.util.List<java.lang.reflect.Field> findFields(java.lang.Class clazz,
                                                                    Footnote annotation)

Get all the annotated fields for the class clazz including those from the superclasses.

Parameters:

clazz - The class to search.

annotation - The annotation that the fields must have.

Returns:

The list of fields with the required annotation.

findMethods

protected static java.util.List<java.lang.reflect.Method> findMethods(java.lang.Class clazz,
                                                                      Footnote annotation)

Get all the annotated methods for the class clazz including those from the superclasses.

Parameters:

clazz - The class to search.

annotation - The annotation that the methods must have.

Returns:

The list of fields with the required annotation.

findSetter

protected static java.lang.reflect.Method findSetter(java.lang.Class clazz,
                                                     java.lang.reflect.Method getter)

Find the setter for the corresponding getter in the specified class. Will look in superclasses if necessary.

Parameters:

clazz - The class to search in.

getter - The getter to match.

Returns:

The setter or null if it cannot be found.

invoke

public static void invoke(Footnote annotation,
                          java.lang.Object instance,
                          java.lang.Object... params)

Call all the matching annotated methods in the instance using the parameters specified. Note: will not accept null parameters.

Parameters:

annotation - The annotation that the methods must have.

instance - The instance to invoke the methods on.

params - The parameters to invoke the methods with (also the signature for the methods is formed from these parameters)

invoke

public static void invoke(java.lang.annotation.Annotation annotation,
                          java.lang.Object instance,
                          java.lang.Object... params)

Call all the matching annotated methods in the instance using the parameters specified. Note: will not accept null parameters.

Parameters:

annotation - The annotation that the methods must have.

instance - The instance to invoke the methods on.

params - The parameters to invoke the methods with (also the signature for the methods is formed from these parameters)

Since:

1.1

invoke

public static void invoke(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                          java.lang.Object instance,
                          java.lang.Object... params)

Call all the matching annotated methods in the instance using the parameters specified. Note: will not accept null parameters.

Parameters:

annotationType - The annotation class that the methods must have.

instance - The instance to invoke the methods on.

params - The parameters to invoke the methods with (also the signature for the methods is formed from these parameters)

Since:

1.1

matchParameters

protected static boolean matchParameters(java.lang.reflect.Method method,
                                         java.lang.Class<?>[] paramTypes)

Check if the method's parameters match paramTypes. The parameters of the method need only be assignment compatible for a match to be made.

Parameters:

method - The method to check.

paramTypes - The parameter types to match against.

Returns:

true if we have a match.

apply

public abstract void apply(java.lang.Object instance)

Apply the gloss to the instance

Parameters:

instance - The object to which the gloss should be applied

applyStatic

public abstract void applyStatic(java.lang.Class instanceClass)

Apply the gloss to the class

Parameters:

instanceClass - The object to which the gloss should be applied

applyStatic

public static void applyStatic(Footnote annotation,
                               java.lang.Class instanceClass,
                               int injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

applyStatic

public static void applyStatic(java.lang.annotation.Annotation annotation,
                               java.lang.Class instanceClass,
                               int injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instance to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                               java.lang.Class instanceClass,
                               int injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(Footnote annotation,
                               java.lang.Class instanceClass,
                               short injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

applyStatic

public static void applyStatic(java.lang.annotation.Annotation annotation,
                               java.lang.Class instanceClass,
                               short injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                               java.lang.Class instanceClass,
                               short injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(Footnote annotation,
                               java.lang.Class instanceClass,
                               long injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

applyStatic

public static void applyStatic(java.lang.annotation.Annotation annotation,
                               java.lang.Class instanceClass,
                               long injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                               java.lang.Class instanceClass,
                               long injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(Footnote annotation,
                               java.lang.Class instanceClass,
                               float injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

applyStatic

public static void applyStatic(java.lang.annotation.Annotation annotation,
                               java.lang.Class instanceClass,
                               float injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                               java.lang.Class instanceClass,
                               float injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(Footnote annotation,
                               java.lang.Class instanceClass,
                               double injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

applyStatic

public static void applyStatic(java.lang.annotation.Annotation annotation,
                               java.lang.Class instanceClass,
                               double injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                               java.lang.Class instanceClass,
                               double injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(Footnote annotation,
                               java.lang.Class instanceClass,
                               char injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

applyStatic

public static void applyStatic(java.lang.annotation.Annotation annotation,
                               java.lang.Class instanceClass,
                               char injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                               java.lang.Class instanceClass,
                               char injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(Footnote annotation,
                               java.lang.Class instanceClass,
                               byte injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

applyStatic

public static void applyStatic(java.lang.annotation.Annotation annotation,
                               java.lang.Class instanceClass,
                               byte injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                               java.lang.Class instanceClass,
                               byte injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(Footnote annotation,
                               java.lang.Class instanceClass,
                               boolean injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

applyStatic

public static void applyStatic(java.lang.annotation.Annotation annotation,
                               java.lang.Class instanceClass,
                               boolean injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotation - The annotation to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1

applyStatic

public static void applyStatic(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType,
                               java.lang.Class instanceClass,
                               boolean injection)

Apply the specified gloss to the instance. Tries to inject any annotated fields, properties or setter methods with the injection.
Matching rules:

• Fields: Must be assignment compatible with injection any access type (public, protected, default or private) will be identified, including those from superclasses, however, if a required call to Field.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.
• Properties: any access type (public, protected, default or private). The annotation must be on the getter. The getter must return a value that is assignment compatible with injection. The name must begin with get unless the return type is boolean in which case is is acceptable.

  Cannot inject elements into an array property, must inject the entire array (i.e. will not match a getXXX(int index) method. The corresponding setter must exist. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

• Setter methods:The name must begin with set. Cannot inject elements into an array property, must inject the entire array (i.e. will not match a setXXX(int index, T value) method. If the setter is not accessible and the required call to Method.setAccessible fails due to a SecurityManager or other restriction then the injection will fail.

Parameters:

annotationType - The annotation class to match

instanceClass - The instanceClass to search

injection - The value to inject

Since:

1.1