Style: Place nullable annotation next to return value

Author: ljacqu

src/main/java/ch/jalu/typeresolver/CommonTypeUtils.java

@@ -53,8 +53,7 @@ public static boolean hasExplicitUpperBound(WildcardType wildcardType) {
      * @param type the type to return as class if possible
      * @return the type as class, or null if not applicable
      */
-    @Nullable
-    public static Class<?> getDefinitiveClass(Type type) {
+    public static @Nullable Class<?> getDefinitiveClass(Type type) {
         if (type instanceof Class<?>) {
             return (Class<?>) type;
         } else if (type instanceof ParameterizedType) {

src/main/java/ch/jalu/typeresolver/TypeInfo.java

@@ -82,8 +82,7 @@ public Type getType() {
      * @param index the index of the type parameter to get (0-based)
      * @return the type argument for the given index, null if not applicable
      */
-    @Nullable
-    public TypeInfo getTypeArgumentInfo(int index) {
+    public @Nullable TypeInfo getTypeArgumentInfo(int index) {
         if (type instanceof ParameterizedType) {
             Type[] typeArguments = ((ParameterizedType) type).getActualTypeArguments();
             if (index < typeArguments.length) {
@@ -109,8 +108,7 @@ public TypeInfo getTypeArgumentInfo(int index) {
      * @param index the index of the type parameter to get (0-based)
      * @return the type argument as safe-to-write class, null if not applicable
      */
-    @Nullable
-    public Class<?> getTypeArgumentAsClass(int index) {
+    public @Nullable Class<?> getTypeArgumentAsClass(int index) {
         TypeInfo genericTypeInfo = getTypeArgumentInfo(index);
         return genericTypeInfo == null ? null : genericTypeInfo.toClass();
     }
@@ -131,8 +129,7 @@ public Class<?> getTypeArgumentAsClass(int index) {
      *         (e.g. setting a value to a field or adding to a collection);
      *         null if not applicable
      */
-    @Nullable
-    public Class<?> toClass() {
+    public @Nullable Class<?> toClass() {
         return TypeToClassUtils.getSafeToWriteClass(type);
     }
 
@@ -193,8 +190,7 @@ public boolean isAssignableFrom(Class<?> clazz) {
      *
      * @return the enclosing type, or null if this type is not a nested type
      */
-    @Nullable
-    public TypeInfo getEnclosingType() {
+    public @Nullable TypeInfo getEnclosingType() {
         Type enclosingType = null;
         if (type instanceof Class<?>) {
             enclosingType = ((Class<?>) type).getEnclosingClass();
@@ -210,8 +206,7 @@ public TypeInfo getEnclosingType() {
      *
      * @return the component type of this array type, or null if this type is not an array
      */
-    @Nullable
-    public TypeInfo getComponentType() {
+    public @Nullable TypeInfo getComponentType() {
         Type componentType = null;
         if (type instanceof Class<?>) {
             componentType = ((Class<?>) type).getComponentType();
@@ -249,8 +244,7 @@ public TypeInfo resolve(Type type) {
      * @param clazz the desired superclass to get the info for
      * @return the type info of the superclass of the given class, or null if this wrapped type is not a supertype
      */
-    @Nullable
-    public TypeInfo resolveSuperclass(Class<?> clazz) {
+    public @Nullable TypeInfo resolveSuperclass(Class<?> clazz) {
         final Class<?> thisClass = toClass();
         if (thisClass == null || !clazz.isAssignableFrom(thisClass)) {
             return null;
@@ -297,8 +291,7 @@ public void visitAllTypes(Consumer<Type> typeVisitor) {
         TypeVisitor.visitAllTypes(type, getOrInitResolver(), typeVisitor);
     }
 
-    @Nullable
-    private Type getOwnerTypeForResolvedParameterizedType(Class<?> superclass) {
+    private @Nullable Type getOwnerTypeForResolvedParameterizedType(Class<?> superclass) {
         Class<?> enclosingClass = superclass.getEnclosingClass();
         // Return enclosing class without type arguments if the nested class is static (in line with Java behavior)
         if (enclosingClass == null || Modifier.isStatic(superclass.getModifiers())) {

src/main/java/ch/jalu/typeresolver/TypeToClassUtils.java

@@ -27,8 +27,7 @@ private TypeToClassUtils() {
      * @param type the type to process
      * @return safe-to-write class of the type, or null if not known
      */
-    @Nullable
-    public static Class<?> getSafeToWriteClass(@Nullable Type type) {
+    public static @Nullable Class<?> getSafeToWriteClass(@Nullable Type type) {
         if (type instanceof Class<?>) {
             return (Class<?>) type;
         } else if (type instanceof ParameterizedType) {
@@ -59,8 +58,7 @@ public static Class<?> getSafeToReadClass(@Nullable Type type) {
         return clazz == null ? Object.class : clazz;
     }
 
-    @Nullable
-    private static Class<?> getSafeToReadClassOrNull(@Nullable Type type) {
+    private static @Nullable Class<?> getSafeToReadClassOrNull(@Nullable Type type) {
         if (type instanceof Class<?>) {
             return (Class<?>) type;
         } else if (type instanceof ParameterizedType) {
@@ -88,8 +86,7 @@ private static Class<?> getSafeToReadClassOrNull(@Nullable Type type) {
         return null;
     }
 
-    @Nullable
-    private static Class<?> getFirstNonNull(Function<Type, Class<?>> converter, Type[] inputs) {
+    private static @Nullable Class<?> getFirstNonNull(Function<Type, Class<?>> converter, Type[] inputs) {
         return Arrays.stream(inputs)
             .map(converter)
             .filter(Objects::nonNull)

src/main/java/ch/jalu/typeresolver/classutil/ClassTypeCallback.java

@@ -20,8 +20,7 @@ public abstract class ClassTypeCallback<R> {
      * @param enumClass the enum class
      * @return result or null
      */
-    @Nullable
-    public R forEnum(Class<? extends Enum<?>> enumClass) {
+    public @Nullable R forEnum(Class<? extends Enum<?>> enumClass) {
         return null;
     }
 
@@ -35,8 +34,7 @@ public R forEnum(Class<? extends Enum<?>> enumClass) {
      * @param enumEntryClass the synthetic class of the enum entry
      * @return result or null
      */
-    @Nullable
-    public R forEnumEntry(Class<? extends Enum<?>> enumClass, Class<? extends Enum<?>> enumEntryClass) {
+    public @Nullable R forEnumEntry(Class<? extends Enum<?>> enumClass, Class<? extends Enum<?>> enumEntryClass) {
         return null;
     }
 
@@ -46,8 +44,7 @@ public R forEnumEntry(Class<? extends Enum<?>> enumClass, Class<? extends Enum<?
      * @param annotationClass the annotation class
      * @return result or null
      */
-    @Nullable
-    public R forAnnotation(Class<? extends Annotation> annotationClass) {
+    public @Nullable R forAnnotation(Class<? extends Annotation> annotationClass) {
         return null;
     }
 
@@ -57,8 +54,7 @@ public R forAnnotation(Class<? extends Annotation> annotationClass) {
      * @param primitiveClass the primitive class (or void)
      * @return result or null
      */
-    @Nullable
-    public R forPrimitiveType(Class<?> primitiveClass) {
+    public @Nullable R forPrimitiveType(Class<?> primitiveClass) {
         return null;
     }
 
@@ -71,8 +67,7 @@ public R forPrimitiveType(Class<?> primitiveClass) {
      * @param arrayClass the array class
      * @return result or null
      */
-    @Nullable
-    public R forArrayType(Class<?> arrayClass) {
+    public @Nullable R forArrayType(Class<?> arrayClass) {
         return null;
     }
 
@@ -82,8 +77,7 @@ public R forArrayType(Class<?> arrayClass) {
      * @param interfaceType the interface
      * @return result or null
      */
-    @Nullable
-    public R forInterface(Class<?> interfaceType) {
+    public @Nullable R forInterface(Class<?> interfaceType) {
         return null;
     }
 
@@ -93,8 +87,7 @@ public R forInterface(Class<?> interfaceType) {
      * @param proxyClass the proxy class
      * @return result or null
      */
-    @Nullable
-    public R forProxyClass(Class<?> proxyClass) {
+    public @Nullable R forProxyClass(Class<?> proxyClass) {
         return null;
     }
 
@@ -104,8 +97,7 @@ public R forProxyClass(Class<?> proxyClass) {
      * @param regularClass the Java class
      * @return result or null
      */
-    @Nullable
-    public R forRegularClass(Class<?> regularClass) {
+    public @Nullable R forRegularClass(Class<?> regularClass) {
         return null;
     }
 }

src/main/java/ch/jalu/typeresolver/classutil/ClassUtils.java

@@ -199,8 +199,7 @@ public static String getClassName(@Nullable Object object) {
      * @param object the object to inspect, or null
      * @return the semantic type (only null if the object was null)
      */
-    @Nullable
-    public static Class<?> getSemanticType(@Nullable Object object) {
+    public static @Nullable Class<?> getSemanticType(@Nullable Object object) {
         if (object == null) {
             return null;
         } else if (object instanceof Enum<?>) {
@@ -296,8 +295,8 @@ public static ClassType getType(Class<?> clazz) {
      * @param <R> the callback's result type
      * @return the result from the callback (may be null)
      */
-    @Nullable
-    public static <R> R processClassByType(@Nullable Class<?> clazz, ClassTypeCallback<? extends R> typeCallback) {
+    public static <R> @Nullable R processClassByType(@Nullable Class<?> clazz,
+                                                     ClassTypeCallback<? extends R> typeCallback) {
         ClassType type = getType(clazz);
         if (type == null) {
             return null;

src/main/java/ch/jalu/typeresolver/numbers/NumberTypes.java

@@ -38,9 +38,8 @@ private NumberTypes() {
      * @param <T> the class's type
      * @return the number type for the given class, null if not available
      */
-    @Nullable
     @SuppressWarnings("unchecked")
-    public static <T> NumberType<T> from(@Nullable Class<T> clazz) {
+    public static <T> @Nullable NumberType<T> from(@Nullable Class<T> clazz) {
         return (NumberType<T>) NUMBER_TYPES_BY_CLASS.get(clazz);
     }
 
@@ -66,8 +65,7 @@ public static Stream<NumberType<?>> streamThroughAll() {
      * @param object the object to unwrap
      * @return the number value the object could be unwrapped to
      */
-    @Nullable
-    public static Number unwrapToStandardNumberType(@Nullable Object object) {
+    public static @Nullable Number unwrapToStandardNumberType(@Nullable Object object) {
         if (object instanceof Character) {
             return (int) (Character) object;
         } else if (object instanceof Number) {

src/main/java/ch/jalu/typeresolver/numbers/StandardNumberType.java

@@ -213,8 +213,7 @@ public ValueRangeComparison compareToValueRange(Number number) {
      * @param clazz the class to find the number type for
      * @return the instance matching the given type, or null if not applicable
      */
-    @Nullable
-    public static StandardNumberType fromClass(Class<?> clazz) {
+    public static @Nullable StandardNumberType fromClass(Class<?> clazz) {
         return TYPE_TO_ENUM_ENTRIES.get(PrimitiveType.toReferenceType(clazz));
     }
 
@@ -228,9 +227,8 @@ public static StandardNumberType fromClass(Class<?> clazz) {
      * @return the instance matching the given type, or null if not applicable
      * @see NumberTypes#from
      */
-    @Nullable
     @SuppressWarnings("unchecked")
-    public static <T extends Number> NumberType<T> fromNumberClass(@Nullable Class<T> clazz) {
+    public static <T extends Number> @Nullable NumberType<T> fromNumberClass(@Nullable Class<T> clazz) {
         return fromClass(clazz);
     }
 

src/main/java/ch/jalu/typeresolver/numbers/StandardValueRange.java

@@ -143,27 +143,23 @@ public String toString() {
         return "StandardValueRange[" + name() + "]";
     }
 
-    @Nullable
     @Override
-    public BigDecimal getMinValue() {
+    public @Nullable BigDecimal getMinValue() {
         return min;
     }
 
-    @Nullable
     @Override
-    public BigDecimal getMaxValue() {
+    public @Nullable BigDecimal getMaxValue() {
         return max;
     }
 
-    @Nullable
     @Override
-    public Number getMinInOwnType() {
+    public @Nullable Number getMinInOwnType() {
         return minInOwnType;
     }
 
-    @Nullable
     @Override
-    public Number getMaxInOwnType() {
+    public @Nullable Number getMaxInOwnType() {
         return maxInOwnType;
     }
 }

src/main/java/ch/jalu/typeresolver/numbers/ValueRange.java

@@ -14,26 +14,22 @@ public interface ValueRange<T> {
     /**
      * @return the minimum value this type can represent; null if there is no explicit bound
      */
-    @Nullable
-    BigDecimal getMinValue();
+    @Nullable BigDecimal getMinValue();
 
     /**
      * @return the maximum value this type can represent; null if there is no explicit bound
      */
-    @Nullable
-    BigDecimal getMaxValue();
+    @Nullable BigDecimal getMaxValue();
 
     /**
      * @return the smallest finite value the type can represent, in the type itself (null if the type has no limit)
      */
-    @Nullable
-    T getMinInOwnType();
+    @Nullable T getMinInOwnType();
 
     /**
      * @return the largest finite value the type can represent, in the type itself (null if the type has no limit)
      */
-    @Nullable
-    T getMaxInOwnType();
+    @Nullable T getMaxInOwnType();
 
     /**
      * @return true if this value can represent decimals, false otherwise

src/main/java/ch/jalu/typeresolver/primitives/PrimitiveType.java

@@ -85,8 +85,7 @@ public boolean matches(@Nullable Class<?> clazz) {
      * @param clazz the class to search for (primitive or reference type of a primitive-reference class pair)
      * @return the corresponding entry, or null if not applicable
      */
-    @Nullable
-    public static PrimitiveType from(Class<?> clazz) {
+    public static @Nullable PrimitiveType from(Class<?> clazz) {
         return PRIMITIVES_BY_CLASS.get(clazz);
     }