AnnotationStringConverterFactory.java
/*
* Copyright 2010-present Stephen Colebourne
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.joda.convert;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/**
* Factory for {@code StringConverter} looking up annotations.
* <p>
* This class is immutable and thread-safe.
*
* @since 1.5
*/
final class AnnotationStringConverterFactory implements StringConverterFactory {
/**
* Singleton instance.
*/
static final AnnotationStringConverterFactory INSTANCE = new AnnotationStringConverterFactory();
/**
* Restricted constructor.
*/
private AnnotationStringConverterFactory() {
}
//-----------------------------------------------------------------------
/**
* Finds a converter by type.
*
* @param cls the type to lookup, not null
* @return the converter, null if not found
* @throws RuntimeException (or subclass) if source code is invalid
*/
@Override
public StringConverter<?> findConverter(Class<?> cls) {
return findAnnotatedConverter(cls); // capture generics
}
/**
* Finds a converter searching annotated.
*
* @param <T> the type of the converter
* @param cls the class to find a method for, not null
* @return the converter, not null
* @throws RuntimeException if none found
*/
private <T> StringConverter<T> findAnnotatedConverter(Class<T> cls) {
Method toString = findToStringMethod(cls); // checks superclasses
if (toString == null) {
return null;
}
TypedFromStringConverter<T> fromString = findAnnotatedFromStringConverter(cls);
if (fromString == null) {
throw new IllegalStateException("Class annotated with @ToString but not with @FromString: " + cls.getName());
}
return new ReflectionStringConverter<T>(cls, toString, fromString);
}
/**
* Finds a from-string converter by type.
*
* @param <T> the type of the converter
* @param cls the type to lookup, not null
* @return the converter, null if not found
* @throws RuntimeException (or subclass) if source code is invalid
*/
<T> TypedFromStringConverter<T> findFromStringConverter(Class<T> cls) {
return findAnnotatedFromStringConverter(cls); // capture generics
}
/**
* Finds a from-string converter.
*
* @param <T> the type of the converter
* @param cls the class to find a method for, not null
* @return the converter, null if not found
* @throws RuntimeException if none found
*/
private <T> TypedFromStringConverter<T> findAnnotatedFromStringConverter(Class<T> cls) {
TypedFromStringConverter<T> con = findFromStringConstructor(cls);
TypedFromStringConverter<T> mth = findFromStringMethod(cls, con == null); // optionally checks superclasses
if (con != null && mth != null) {
throw new IllegalStateException("Both method and constructor are annotated with @FromString: " + cls.getName());
}
return (con != null ? con : mth);
}
//-------------------------------------------------------------------------
/**
* Finds the conversion method.
*
* @param cls the class to find a method for, not null
* @return the method to call, null means use {@code toString}
* @throws RuntimeException if invalid
*/
private Method findToStringMethod(Class<?> cls) {
Method matched = null;
// find in superclass hierarchy
Class<?> loopCls = cls;
while (loopCls != null && matched == null) {
Method[] methods = loopCls.getDeclaredMethods();
for (Method method : methods) {
if (!method.isBridge() && !method.isSynthetic()) {
ToString toString = method.getAnnotation(ToString.class);
if (toString != null) {
if (matched != null) {
throw new IllegalStateException("Two methods are annotated with @ToString: " + cls.getName());
}
matched = method;
}
}
}
loopCls = loopCls.getSuperclass();
}
// find in immediate parent interfaces
if (matched == null) {
for (Class<?> loopIfc : eliminateEnumSubclass(cls).getInterfaces()) {
Method[] methods = loopIfc.getDeclaredMethods();
for (Method method : methods) {
if (!method.isBridge() && !method.isSynthetic()) {
ToString toString = method.getAnnotation(ToString.class);
if (toString != null) {
if (matched != null) {
throw new IllegalStateException("Two methods are annotated with @ToString on interfaces: " + cls.getName());
}
matched = method;
}
}
}
}
}
return matched;
}
//-------------------------------------------------------------------------
/**
* Finds the conversion method.
*
* @param <T> the type of the converter
* @param cls the class to find a method for, not null
* @return the method to call, null means none found
* @throws RuntimeException if invalid
*/
private <T> TypedFromStringConverter<T> findFromStringConstructor(Class<T> cls) {
Constructor<T> con;
try {
con = cls.getDeclaredConstructor(String.class);
} catch (NoSuchMethodException ex) {
try {
con = cls.getDeclaredConstructor(CharSequence.class);
} catch (NoSuchMethodException ex2) {
return null;
}
}
FromString fromString = con.getAnnotation(FromString.class);
if (fromString == null) {
return null;
}
return new ConstructorFromStringConverter<T>(cls, con);
}
/**
* Finds the conversion method.
*
* @param cls the class to find a method for, not null
* @param searchSuperclasses whether to search superclasses
* @return the method to call, null means not found
* @throws RuntimeException if invalid
*/
private <T> TypedFromStringConverter<T> findFromStringMethod(Class<T> cls, boolean searchSuperclasses) {
// find in superclass hierarchy
Class<?> loopCls = cls;
while (loopCls != null) {
Method fromString = findFromString(loopCls);
if (fromString != null) {
return new MethodFromStringConverter<T>(cls, fromString, loopCls);
}
if (searchSuperclasses == false) {
break;
}
loopCls = loopCls.getSuperclass();
}
// find in immediate parent interfaces
TypedFromStringConverter<T> matched = null;
if (searchSuperclasses) {
for (Class<?> loopIfc : eliminateEnumSubclass(cls).getInterfaces()) {
Method fromString = findFromString(loopIfc);
if (fromString != null) {
if (matched != null) {
throw new IllegalStateException("Two different interfaces are annotated with " +
"@FromString or @FromStringFactory: " + cls.getName());
}
matched = new MethodFromStringConverter<T>(cls, fromString, loopIfc);
}
}
}
return matched;
}
/**
* Finds the conversion method.
*
* @param cls the class to find a method for, not null
* @param matched the matched method, may be null
* @return the method to call, null means not found
* @throws RuntimeException if invalid
*/
private Method findFromString(Class<?> cls) {
// find in declared methods
Method[] methods = cls.getDeclaredMethods();
Method matched = null;
for (Method method : methods) {
if (!method.isBridge() && !method.isSynthetic()) {
FromString fromString = method.getAnnotation(FromString.class);
if (fromString != null) {
if (matched != null) {
throw new IllegalStateException("Two methods are annotated with @FromString: " + cls.getName());
}
matched = method;
}
}
}
// check for factory
FromStringFactory factory = cls.getAnnotation(FromStringFactory.class);
if (factory != null) {
if (matched != null) {
throw new IllegalStateException("Class annotated with @FromString and @FromStringFactory: " + cls.getName());
}
Method[] factoryMethods = factory.factory().getDeclaredMethods();
for (Method method : factoryMethods) {
if (!method.isBridge() && !method.isSynthetic()) {
// handle factory containing multiple FromString for different types
if (cls.isAssignableFrom(method.getReturnType())) {
FromString fromString = method.getAnnotation(FromString.class);
if (fromString != null) {
if (matched != null) {
throw new IllegalStateException("Two methods are annotated with @FromString on the factory: " + factory.factory().getName());
}
matched = method;
}
}
}
}
}
return matched;
}
// eliminates enum subclass as they are pesky
private Class<?> eliminateEnumSubclass(Class<?> cls) {
Class<?> sup = cls.getSuperclass();
if (sup != null && sup.getSuperclass() == Enum.class) {
return sup;
}
return cls;
}
//-----------------------------------------------------------------------
@Override
public String toString() {
return getClass().getSimpleName();
}
}