package org.togglz.core.util;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import org.togglz.core.Feature;
import org.togglz.core.annotation.EnabledByDefault;
import org.togglz.core.annotation.FeatureAttribute;
import org.togglz.core.annotation.InfoLink;
import org.togglz.core.annotation.Label;
import org.togglz.core.annotation.Owner;
/**
* Utility class to read annotation on feature enums.
*
* @author Christian Kaltepoth
* @author Eli Abramovitch
*/
public class FeatureAnnotations {
public static String getLabel(Feature feature) {
Label label = getAnnotation(feature, Label.class);
if (label != null) {
return label.value();
}
return feature.name();
}
public static String getOwner(Feature feature) {
Owner owner = getAnnotation(feature, Owner.class);
if (owner != null) {
return owner.value();
}
return null;
}
public static String getInfoLink(Feature feature) {
InfoLink infoLink = getAnnotation(feature, InfoLink.class);
if (infoLink != null) {
return infoLink.value();
}
return null;
}
public static boolean isEnabledByDefault(Feature feature) {
return isAnnotationPresent(feature, EnabledByDefault.class);
}
public static boolean isAnnotationPresent(Feature feature, Class<? extends Annotation> annotationType) {
return getAnnotation(feature, annotationType) != null;
}
public static Set<Annotation> getAnnotations(Feature feature) {
Set<Annotation> annotations = new HashSet<Annotation>();
try {
Class<? extends Feature> featureClass = feature.getClass();
Annotation[] fieldAnnotations = featureClass.getField(feature.name()).getAnnotations();
Annotation[] classAnnotations = featureClass.getAnnotations();
annotations.addAll(Arrays.asList(fieldAnnotations));
annotations.addAll(Arrays.asList(classAnnotations));
return annotations;
} catch (SecurityException e) {
// ignore
} catch (NoSuchFieldException e) {
// ignore
}
return annotations;
}
public static <A extends Annotation> A getAnnotation(Feature feature, Class<A> annotationType) {
try {
Class<? extends Feature> featureClass = feature.getClass();
A fieldAnnotation = featureClass.getField(feature.name()).getAnnotation(annotationType);
A classAnnotation = featureClass.getAnnotation(annotationType);
return fieldAnnotation != null ? fieldAnnotation : classAnnotation;
} catch (SecurityException e) {
// ignore
} catch (NoSuchFieldException e) {
// ignore
}
return null;
}
/**
* Checks whether the supplied annotation specifies a feature attribute. If so, it returns an String array containing the
* name of the attribute at the first and the value at the second position. Returns <code>null</code> if no attribute was
* found.
*/
public static String[] getFeatureAttribute(Annotation annotation) {
try {
// only annotations which are annotated with @FeatureAttribute are interesting
FeatureAttribute details = annotation.annotationType().getAnnotation(FeatureAttribute.class);
if (details != null) {
// this is the name of the feature attribute
String attributeName = details.value();
// find the method to invoke on the annotation to read the value of the feature attribute
Method method = annotation.getClass().getMethod(details.annotationAttribute());
if (method != null) {
String attributeValue = method.invoke(annotation).toString();
return new String[]{attributeName, attributeValue};
}
}
} catch (NoSuchMethodException e) {
throw new IllegalStateException(e);
} catch (SecurityException e) {
throw new IllegalStateException(e);
} catch (IllegalAccessException e) {
throw new IllegalStateException(e);
} catch (IllegalArgumentException e) {
throw new IllegalStateException(e);
} catch (InvocationTargetException e) {
throw new IllegalStateException(e);
}
return null;
}
}