http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaConfigurationBuilderImpl.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaConfigurationBuilderImpl.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaConfigurationBuilderImpl.java index 507481e..0113da1 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaConfigurationBuilderImpl.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaConfigurationBuilderImpl.java @@ -40,9 +40,9 @@ import java.util.Set; public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl implements JavaConfigurationBuilder { - public JavaConfigurationBuilderImpl(URL[] jars, - Configuration[] confs, - Class<? extends ExternalConstructor<?>>[] parsers) + public JavaConfigurationBuilderImpl(final URL[] jars, + final Configuration[] confs, + final Class<? extends ExternalConstructor<?>>[] parsers) throws BindException { super(jars, confs, parsers); } @@ -51,15 +51,15 @@ public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl super(); } - public JavaConfigurationBuilderImpl(URL[] jars) throws BindException { + public JavaConfigurationBuilderImpl(final URL[] jars) throws BindException { super(jars); } - JavaConfigurationBuilderImpl(JavaConfigurationBuilderImpl impl) { + JavaConfigurationBuilderImpl(final JavaConfigurationBuilderImpl impl) { super(impl); } - public JavaConfigurationBuilderImpl(Configuration[] confs) + public JavaConfigurationBuilderImpl(final Configuration[] confs) throws BindException { super(confs); } @@ -69,19 +69,19 @@ public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl return new JavaConfigurationImpl(new JavaConfigurationBuilderImpl(this)); } - private Node getNode(Class<?> c) { + private Node getNode(final Class<?> c) { return ((JavaClassHierarchy) namespace).getNode(c); } @Override - public <T> JavaConfigurationBuilder bind(Class<T> c, Class<?> val) throws BindException { + public <T> JavaConfigurationBuilder bind(final Class<T> c, final Class<?> val) throws BindException { super.bind(getNode(c), getNode(val)); return this; } @Override @SuppressWarnings("unchecked") - public <T> JavaConfigurationBuilder bindImplementation(Class<T> c, Class<? extends T> d) + public <T> JavaConfigurationBuilder bindImplementation(final Class<T> c, final Class<? extends T> d) throws BindException { final Node cn = getNode(c); final Node dn = getNode(d); @@ -117,10 +117,10 @@ public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl } @Override - public <T> JavaConfigurationBuilder bindNamedParameter(Class<? extends Name<T>> iface, - Class<? extends T> impl) throws BindException { - Node ifaceN = getNode(iface); - Node implN = getNode(impl); + public <T> JavaConfigurationBuilder bindNamedParameter(final Class<? extends Name<T>> iface, + final Class<? extends T> impl) throws BindException { + final Node ifaceN = getNode(iface); + final Node implN = getNode(impl); if (!(ifaceN instanceof NamedParameterNode)) { throw new BindException("Type mismatch when setting named parameter " + ifaceN + " Expected NamedParameterNode"); @@ -130,8 +130,8 @@ public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl } @SuppressWarnings({"unchecked"}) - public <T> JavaConfigurationBuilder bindConstructor(Class<T> c, - Class<? extends ExternalConstructor<? extends T>> v) + public <T> JavaConfigurationBuilder bindConstructor(final Class<T> c, + final Class<? extends ExternalConstructor<? extends T>> v) throws BindException { final Node n = getNode(c); final Node m = getNode(v); @@ -147,7 +147,7 @@ public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl @SuppressWarnings("unchecked") @Override - public <T> JavaConfigurationBuilder bindSetEntry(Class<? extends Name<Set<T>>> iface, String value) + public <T> JavaConfigurationBuilder bindSetEntry(final Class<? extends Name<Set<T>>> iface, final String value) throws BindException { final Node n = getNode(iface); @@ -165,8 +165,8 @@ public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl @SuppressWarnings("unchecked") @Override - public <T> JavaConfigurationBuilder bindSetEntry(Class<? extends Name<Set<T>>> iface, Class<? extends T> impl) - throws BindException { + public <T> JavaConfigurationBuilder bindSetEntry( + final Class<? extends Name<Set<T>>> iface, final Class<? extends T> impl) throws BindException { final Node n = getNode(iface); final Node m = getNode(impl); @@ -202,10 +202,10 @@ public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl */ @SuppressWarnings("unchecked") @Override - public <T> JavaConfigurationBuilder bindList(Class<? extends Name<List<T>>> iface, List implList) + public <T> JavaConfigurationBuilder bindList(final Class<? extends Name<List<T>>> iface, final List implList) throws BindException { final Node n = getNode(iface); - List<Object> result = new ArrayList<>(); + final List<Object> result = new ArrayList<>(); if (!(n instanceof NamedParameterNode)) { throw new BindException("BindList got an interface that resolved to " + n + "; expected a NamedParameter"); @@ -216,7 +216,7 @@ public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl } if (!implList.isEmpty()) { final Type valType = ReflectionUtilities.getInterfaceTarget(List.class, listType); - for (Object item : implList) { + for (final Object item : implList) { if (item instanceof Class) { if (!ReflectionUtilities.getRawClass(valType).isAssignableFrom((Class) item)) { throw new BindException("BindList got a list element which is not assignable to the given Type; " + @@ -237,7 +237,7 @@ public class JavaConfigurationBuilderImpl extends ConfigurationBuilderImpl } private class JavaConfigurationImpl extends ConfigurationImpl { - JavaConfigurationImpl(JavaConfigurationBuilderImpl builder) { + JavaConfigurationImpl(final JavaConfigurationBuilderImpl builder) { super(builder); } }
http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaInstance.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaInstance.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaInstance.java index 9bac12d..d47ce83 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaInstance.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaInstance.java @@ -24,7 +24,7 @@ import org.apache.reef.tang.types.Node; public final class JavaInstance<T> extends InjectionPlan<T> { final T instance; - public JavaInstance(Node name, T instance) { + public JavaInstance(final Node name, final T instance) { super(name); this.instance = instance; } http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaNodeFactory.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaNodeFactory.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaNodeFactory.java index b7a2964..01a1766 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaNodeFactory.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/java/JavaNodeFactory.java @@ -41,7 +41,7 @@ import java.util.Set; public final class JavaNodeFactory { @SuppressWarnings("unchecked") - static <T> ClassNodeImpl<T> createClassNode(Node parent, Class<T> clazz) throws ClassHierarchyException { + static <T> ClassNodeImpl<T> createClassNode(final Node parent, final Class<T> clazz) throws ClassHierarchyException { final boolean injectable; final boolean unit = clazz.isAnnotationPresent(Unit.class); final String simpleName = ReflectionUtilities.getSimpleName(clazz); @@ -65,7 +65,7 @@ public final class JavaNodeFactory { } boolean foundNonStaticInnerClass = false; - for (Class<?> c : clazz.getDeclaredClasses()) { + for (final Class<?> c : clazz.getDeclaredClasses()) { if (!Modifier.isStatic(c.getModifiers())) { foundNonStaticInnerClass = true; } @@ -77,12 +77,12 @@ public final class JavaNodeFactory { " Such @Unit annotations would have no effect, and are therefore disallowed."); } - Constructor<T>[] constructors = (Constructor<T>[]) clazz + final Constructor<T>[] constructors = (Constructor<T>[]) clazz .getDeclaredConstructors(); - MonotonicSet<ConstructorDef<T>> injectableConstructors = new MonotonicSet<>(); - ArrayList<ConstructorDef<T>> allConstructors = new ArrayList<>(); + final MonotonicSet<ConstructorDef<T>> injectableConstructors = new MonotonicSet<>(); + final ArrayList<ConstructorDef<T>> allConstructors = new ArrayList<>(); for (int k = 0; k < constructors.length; k++) { - boolean constructorAnnotatedInjectable = (constructors[k] + final boolean constructorAnnotatedInjectable = (constructors[k] .getAnnotation(Inject.class) != null); if (constructorAnnotatedInjectable && constructors[k].isSynthetic()) { // Not sure if we *can* unit test this one. @@ -94,12 +94,12 @@ public final class JavaNodeFactory { "Detected explicit constructor in class enclosed in @Unit " + fullName + " Such constructors are disallowed."); } - boolean constructorInjectable = constructorAnnotatedInjectable || parentIsUnit; + final boolean constructorInjectable = constructorAnnotatedInjectable || parentIsUnit; // ConstructorDef's constructor checks for duplicate // parameters // The injectableConstructors set checks for ambiguous // boundConstructors. - ConstructorDef<T> def = JavaNodeFactory.createConstructorDef(injectable, + final ConstructorDef<T> def = JavaNodeFactory.createConstructorDef(injectable, constructors[k], constructorAnnotatedInjectable); if (constructorInjectable) { if (injectableConstructors.contains(def)) { @@ -115,9 +115,9 @@ public final class JavaNodeFactory { } final String defaultImplementation; if (clazz.isAnnotationPresent(DefaultImplementation.class)) { - DefaultImplementation defaultImpl + final DefaultImplementation defaultImpl = clazz.getAnnotation(DefaultImplementation.class); - Class<?> defaultImplementationClazz = defaultImpl.value(); + final Class<?> defaultImplementationClazz = defaultImpl.value(); if (defaultImplementationClazz.equals(Void.class)) { defaultImplementation = defaultImpl.name(); // XXX check isAssignableFrom, other type problems here. @@ -142,8 +142,9 @@ public final class JavaNodeFactory { /** * XXX: This method assumes that all generic types have exactly one type parameter. */ - public static <T> NamedParameterNode<T> createNamedParameterNode(Node parent, - Class<? extends Name<T>> clazz, Type argClass) + public static <T> NamedParameterNode<T> createNamedParameterNode(final Node parent, + final Class<? extends Name<T>> clazz, + final Type argClass) throws ClassHierarchyException { Class<?> argRawClass = ReflectionUtilities.getRawClass(argClass); @@ -151,16 +152,18 @@ public final class JavaNodeFactory { final boolean isSet = argRawClass.equals(Set.class); final boolean isList = argRawClass.equals(List.class); + final Type argClazz; if (isSet || isList) { - argClass = ReflectionUtilities.getInterfaceTarget(Collection.class, argClass); - argRawClass = ReflectionUtilities.getRawClass(argClass); + argClazz = ReflectionUtilities.getInterfaceTarget(Collection.class, argClass); + } else { + argClazz = argClass; } final String simpleName = ReflectionUtilities.getSimpleName(clazz); final String fullName = ReflectionUtilities.getFullName(clazz); - final String fullArgName = ReflectionUtilities.getFullName(argClass); - final String simpleArgName = ReflectionUtilities.getSimpleName(argClass); + final String fullArgName = ReflectionUtilities.getFullName(argClazz); + final String simpleArgName = ReflectionUtilities.getSimpleName(argClazz); final NamedParameter namedParameter = clazz.getAnnotation(NamedParameter.class); @@ -206,16 +209,16 @@ public final class JavaNodeFactory { defaultInstanceAsStrings = new String[]{}; } else if (hasClassDefault) { final Class<?> defaultClass = namedParameter.default_class(); - assertIsSubclassOf(clazz, defaultClass, argClass); + assertIsSubclassOf(clazz, defaultClass, argClazz); defaultInstanceAsStrings = new String[]{ReflectionUtilities.getFullName(defaultClass)}; } else if (hasStringDefault) { // Don't know if the string is a class or literal here, so don't bother validating. defaultInstanceAsStrings = new String[]{namedParameter.default_value()}; } else if (hasClassSetDefault) { - Class<?>[] clzs = namedParameter.default_classes(); + final Class<?>[] clzs = namedParameter.default_classes(); defaultInstanceAsStrings = new String[clzs.length]; for (int i = 0; i < clzs.length; i++) { - assertIsSubclassOf(clazz, clzs[i], argClass); + assertIsSubclassOf(clazz, clzs[i], argClazz); defaultInstanceAsStrings[i] = ReflectionUtilities.getFullName(clzs[i]); } } else if (hasStringSetDefault) { @@ -233,11 +236,11 @@ public final class JavaNodeFactory { fullArgName, simpleArgName, isSet, isList, documentation, shortName, defaultInstanceAsStrings); } - private static void assertIsSubclassOf(Class<?> namedParameter, Class<?> defaultClass, - Type argClass) { + private static void assertIsSubclassOf(final Class<?> namedParameter, final Class<?> defaultClass, + final Type argClass) { boolean isSubclass = false; boolean isGenericSubclass = false; - Class<?> argRawClass = ReflectionUtilities.getRawClass(argClass); + final Class<?> argRawClass = ReflectionUtilities.getRawClass(argClass); // Note: We intentionally strip the raw type information here. The reason is to handle // EventHandler-style patterns and collections. @@ -249,11 +252,11 @@ public final class JavaNodeFactory { isSubclass = true; if (argClass instanceof ParameterizedType && c instanceof ParameterizedType) { - ParameterizedType argPt = (ParameterizedType) argClass; - ParameterizedType defaultPt = (ParameterizedType) c; + final ParameterizedType argPt = (ParameterizedType) argClass; + final ParameterizedType defaultPt = (ParameterizedType) c; - Class<?> rawDefaultParameter = ReflectionUtilities.getRawClass(defaultPt.getActualTypeArguments()[0]); - Class<?> rawArgParameter = ReflectionUtilities.getRawClass(argPt.getActualTypeArguments()[0]); + final Class<?> rawDefaultParameter = ReflectionUtilities.getRawClass(defaultPt.getActualTypeArguments()[0]); + final Class<?> rawArgParameter = ReflectionUtilities.getRawClass(argPt.getActualTypeArguments()[0]); for (final Type d : ReflectionUtilities.classAndAncestors(argPt.getActualTypeArguments()[0])) { if (ReflectionUtilities.getRawClass(d).equals(rawDefaultParameter)) { @@ -288,8 +291,8 @@ public final class JavaNodeFactory { } private static <T> ConstructorDef<T> createConstructorDef( - boolean isClassInjectionCandidate, Constructor<T> constructor, - boolean injectable) throws ClassHierarchyException { + final boolean isClassInjectionCandidate, final Constructor<T> constructor, + final boolean injectable) throws ClassHierarchyException { // We don't support injection of non-static member classes with @Inject // annotations. if (injectable && !isClassInjectionCandidate) { @@ -298,13 +301,13 @@ public final class JavaNodeFactory { + ReflectionUtilities.getFullName(constructor.getDeclaringClass())); } // TODO: When we use paramTypes below, we strip generic parameters. Is that OK? - Class<?>[] paramTypes = constructor.getParameterTypes(); - Type[] genericParamTypes = constructor.getGenericParameterTypes(); - Annotation[][] paramAnnotations = constructor.getParameterAnnotations(); + final Class<?>[] paramTypes = constructor.getParameterTypes(); + final Type[] genericParamTypes = constructor.getGenericParameterTypes(); + final Annotation[][] paramAnnotations = constructor.getParameterAnnotations(); if (paramTypes.length != paramAnnotations.length) { throw new IllegalStateException(); } - ConstructorArg[] args = new ConstructorArg[genericParamTypes.length]; + final ConstructorArg[] args = new ConstructorArg[genericParamTypes.length]; for (int i = 0; i < genericParamTypes.length; i++) { // If this parameter is an injection future, unwrap the target class, // and remember by setting isFuture to true. @@ -320,7 +323,7 @@ public final class JavaNodeFactory { // Make node of the named parameter annotation (if any). Parameter named = null; for (int j = 0; j < paramAnnotations[i].length; j++) { - Annotation annotation = paramAnnotations[i][j]; + final Annotation annotation = paramAnnotations[i][j]; if (annotation instanceof Parameter) { if ((!isClassInjectionCandidate) || !injectable) { throw new ClassHierarchyException(constructor + " is not injectable, but it has an @Parameter annotation."); http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferClassHierarchy.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferClassHierarchy.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferClassHierarchy.java index 4b0328f..83c7608 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferClassHierarchy.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferClassHierarchy.java @@ -52,30 +52,29 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { * as snapshots of Java class hierarchies. * @deprecated in 0.12. Use AvroClassHierarchy instead */ - public ProtocolBufferClassHierarchy(ClassHierarchyProto.Node root) { + public ProtocolBufferClassHierarchy(final ClassHierarchyProto.Node root) { namespace = new PackageNodeImpl(); if (!root.hasPackageNode()) { throw new IllegalArgumentException("Expected a package node. Got: " + root); } // Register all the classes. - for (ClassHierarchyProto.Node child : root.getChildrenList()) { + for (final ClassHierarchyProto.Node child : root.getChildrenList()) { parseSubHierarchy(namespace, child); } buildLookupTable(namespace); // Now, register the implementations - for (ClassHierarchyProto.Node child : root.getChildrenList()) { + for (final ClassHierarchyProto.Node child : root.getChildrenList()) { wireUpInheritanceRelationships(child); } } - private static ClassHierarchyProto.Node newClassNode(String name, - String fullName, boolean isInjectionCandidate, - boolean isExternalConstructor, boolean isUnit, - List<ClassHierarchyProto.ConstructorDef> injectableConstructors, - List<ClassHierarchyProto.ConstructorDef> otherConstructors, - List<String> implFullNames, - Iterable<ClassHierarchyProto.Node> children) { + private static ClassHierarchyProto.Node newClassNode( + final String name, final String fullName, final boolean isInjectionCandidate, + final boolean isExternalConstructor, final boolean isUnit, + final List<ClassHierarchyProto.ConstructorDef> injectableConstructors, + final List<ClassHierarchyProto.ConstructorDef> otherConstructors, final List<String> implFullNames, + final Iterable<ClassHierarchyProto.Node> children) { return ClassHierarchyProto.Node .newBuilder() .setName(name) @@ -91,17 +90,17 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { .addAllChildren(children).build(); } - private static ClassHierarchyProto.Node newNamedParameterNode(String name, - String fullName, - String simpleArgClassName, - String fullArgClassName, - boolean isSet, - boolean isList, - String documentation, // can be null - String shortName, // can be null - String[] instanceDefault, // can be null - Iterable<ClassHierarchyProto.Node> children) { - ClassHierarchyProto.NamedParameterNode.Builder namedParameterNodeBuilder + private static ClassHierarchyProto.Node newNamedParameterNode(final String name, + final String fullName, + final String simpleArgClassName, + final String fullArgClassName, + final boolean isSet, + final boolean isList, + final String documentation, // can be null + final String shortName, // can be null + final String[] instanceDefault, // can be null + final Iterable<ClassHierarchyProto.Node> children) { + final ClassHierarchyProto.NamedParameterNode.Builder namedParameterNodeBuilder = ClassHierarchyProto.NamedParameterNode.newBuilder() .setSimpleArgClassName(simpleArgClassName) .setFullArgClassName(fullArgClassName) @@ -123,16 +122,16 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { .addAllChildren(children).build(); } - private static ClassHierarchyProto.Node newPackageNode(String name, - String fullName, - Iterable<ClassHierarchyProto.Node> children) { + private static ClassHierarchyProto.Node newPackageNode(final String name, + final String fullName, + final Iterable<ClassHierarchyProto.Node> children) { return ClassHierarchyProto.Node.newBuilder() .setPackageNode(ClassHierarchyProto.PackageNode.newBuilder().build()) .setName(name).setFullName(fullName).addAllChildren(children).build(); } private static ClassHierarchyProto.ConstructorDef newConstructorDef( - String fullClassName, List<ClassHierarchyProto.ConstructorArg> args) { + final String fullClassName, final List<ClassHierarchyProto.ConstructorArg> args) { return ClassHierarchyProto.ConstructorDef.newBuilder() .setFullClassName(fullClassName).addAllArgs(args).build(); } @@ -141,8 +140,8 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { // protobufs private static ClassHierarchyProto.ConstructorArg newConstructorArg( - String fullArgClassName, String namedParameterName, boolean isFuture) { - ClassHierarchyProto.ConstructorArg.Builder builder = + final String fullArgClassName, final String namedParameterName, final boolean isFuture) { + final ClassHierarchyProto.ConstructorArg.Builder builder = ClassHierarchyProto.ConstructorArg.newBuilder() .setFullArgClassName(fullArgClassName) .setIsInjectionFuture(isFuture); @@ -153,43 +152,43 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { } private static ClassHierarchyProto.ConstructorDef serializeConstructorDef( - ConstructorDef<?> def) { - List<ClassHierarchyProto.ConstructorArg> args = new ArrayList<>(); - for (ConstructorArg arg : def.getArgs()) { + final ConstructorDef<?> def) { + final List<ClassHierarchyProto.ConstructorArg> args = new ArrayList<>(); + for (final ConstructorArg arg : def.getArgs()) { args.add(newConstructorArg(arg.getType(), arg.getNamedParameterName(), arg.isInjectionFuture())); } return newConstructorDef(def.getClassName(), args); } - private static ClassHierarchyProto.Node serializeNode(Node n) { - List<ClassHierarchyProto.Node> children = new ArrayList<>(); - for (Node child : n.getChildren()) { + private static ClassHierarchyProto.Node serializeNode(final Node n) { + final List<ClassHierarchyProto.Node> children = new ArrayList<>(); + for (final Node child : n.getChildren()) { children.add(serializeNode(child)); } if (n instanceof ClassNode) { - ClassNode<?> cn = (ClassNode<?>) n; - ConstructorDef<?>[] injectable = cn.getInjectableConstructors(); - ConstructorDef<?>[] all = cn.getAllConstructors(); - List<ConstructorDef<?>> others = new ArrayList<>(Arrays.asList(all)); + final ClassNode<?> cn = (ClassNode<?>) n; + final ConstructorDef<?>[] injectable = cn.getInjectableConstructors(); + final ConstructorDef<?>[] all = cn.getAllConstructors(); + final List<ConstructorDef<?>> others = new ArrayList<>(Arrays.asList(all)); others.removeAll(Arrays.asList(injectable)); - List<ClassHierarchyProto.ConstructorDef> injectableConstructors = new ArrayList<>(); - for (ConstructorDef<?> inj : injectable) { + final List<ClassHierarchyProto.ConstructorDef> injectableConstructors = new ArrayList<>(); + for (final ConstructorDef<?> inj : injectable) { injectableConstructors.add(serializeConstructorDef(inj)); } - List<ClassHierarchyProto.ConstructorDef> otherConstructors = new ArrayList<>(); - for (ConstructorDef<?> other : others) { + final List<ClassHierarchyProto.ConstructorDef> otherConstructors = new ArrayList<>(); + for (final ConstructorDef<?> other : others) { otherConstructors.add(serializeConstructorDef(other)); } - List<String> implFullNames = new ArrayList<>(); - for (ClassNode<?> impl : cn.getKnownImplementations()) { + final List<String> implFullNames = new ArrayList<>(); + for (final ClassNode<?> impl : cn.getKnownImplementations()) { implFullNames.add(impl.getFullName()); } return newClassNode(cn.getName(), cn.getFullName(), cn.isInjectionCandidate(), cn.isExternalConstructor(), cn.isUnit(), injectableConstructors, otherConstructors, implFullNames, children); } else if (n instanceof NamedParameterNode) { - NamedParameterNode<?> np = (NamedParameterNode<?>) n; + final NamedParameterNode<?> np = (NamedParameterNode<?>) n; return newNamedParameterNode(np.getName(), np.getFullName(), np.getSimpleArgName(), np.getFullArgName(), np.isSet(), np.isList(), np.getDocumentation(), np.getShortName(), np.getDefaultInstanceAsStrings(), children); @@ -207,7 +206,7 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { * @return * @deprecated in 0.12. Use AvroClassHierarchySerializer instead */ - public static ClassHierarchyProto.Node serialize(ClassHierarchy classHierarchy) { + public static ClassHierarchyProto.Node serialize(final ClassHierarchy classHierarchy) { return serializeNode(classHierarchy.getNamespace()); } @@ -243,35 +242,34 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { } } - private static void parseSubHierarchy(Node parent, ClassHierarchyProto.Node n) { + private static void parseSubHierarchy(final Node parent, final ClassHierarchyProto.Node n) { final Node parsed; if (n.hasPackageNode()) { parsed = new PackageNodeImpl(parent, n.getName(), n.getFullName()); } else if (n.hasNamedParameterNode()) { - ClassHierarchyProto.NamedParameterNode np = n.getNamedParameterNode(); + final ClassHierarchyProto.NamedParameterNode np = n.getNamedParameterNode(); parsed = new NamedParameterNodeImpl<Object>(parent, n.getName(), n.getFullName(), np.getFullArgClassName(), np.getSimpleArgClassName(), np.getIsSet(), np.getIsList(), np.getDocumentation(), np.getShortName(), np.getInstanceDefaultList().toArray(new String[0])); } else if (n.hasClassNode()) { - ClassHierarchyProto.ClassNode cn = n.getClassNode(); - List<ConstructorDef<?>> injectableConstructors = new ArrayList<>(); - List<ConstructorDef<?>> allConstructors = new ArrayList<>(); + final ClassHierarchyProto.ClassNode cn = n.getClassNode(); + final List<ConstructorDef<?>> injectableConstructors = new ArrayList<>(); + final List<ConstructorDef<?>> allConstructors = new ArrayList<>(); - for (ClassHierarchyProto.ConstructorDef injectable : cn + for (final ClassHierarchyProto.ConstructorDef injectable : cn .getInjectableConstructorsList()) { - ConstructorDef<?> def = parseConstructorDef(injectable, true); + final ConstructorDef<?> def = parseConstructorDef(injectable, true); injectableConstructors.add(def); allConstructors.add(def); } - for (ClassHierarchyProto.ConstructorDef other : cn + for (final ClassHierarchyProto.ConstructorDef other : cn .getOtherConstructorsList()) { - ConstructorDef<?> def = parseConstructorDef(other, false); + final ConstructorDef<?> def = parseConstructorDef(other, false); allConstructors.add(def); } - @SuppressWarnings("unchecked") - ConstructorDef<Object>[] dummy = new ConstructorDef[0]; + @SuppressWarnings("unchecked") final ConstructorDef<Object>[] dummy = new ConstructorDef[0]; parsed = new ClassNodeImpl<>(parent, n.getName(), n.getFullName(), cn.getIsUnit(), cn.getIsInjectionCandidate(), cn.getIsExternalConstructor(), injectableConstructors.toArray(dummy), @@ -280,16 +278,16 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { throw new IllegalStateException("Bad protocol buffer: got abstract node" + n); } - for (ClassHierarchyProto.Node child : n.getChildrenList()) { + for (final ClassHierarchyProto.Node child : n.getChildrenList()) { parseSubHierarchy(parsed, child); } } private static ConstructorDef<?> parseConstructorDef( - org.apache.reef.tang.proto.ClassHierarchyProto.ConstructorDef def, - boolean isInjectable) { - List<ConstructorArg> args = new ArrayList<>(); - for (ClassHierarchyProto.ConstructorArg arg : def.getArgsList()) { + final org.apache.reef.tang.proto.ClassHierarchyProto.ConstructorDef def, + final boolean isInjectable) { + final List<ConstructorArg> args = new ArrayList<>(); + for (final ClassHierarchyProto.ConstructorArg arg : def.getArgsList()) { args.add(new ConstructorArgImpl(arg.getFullArgClassName(), arg .getNamedParameterName(), arg.getIsInjectionFuture())); } @@ -297,26 +295,27 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { args.toArray(new ConstructorArg[0]), isInjectable); } - private static String getNthPrefix(String str, int n) { - n++; // want this function to be zero indexed... + private static String getNthPrefix(final String str, final int n) { + int j = n; + j++; // want this function to be zero indexed... for (int i = 0; i < str.length(); i++) { - char c = str.charAt(i); + final char c = str.charAt(i); if (c == '.' || c == '$' || c == '+') { - n--; + j--; } - if (n == 0) { + if (j == 0) { return str.substring(0, i); } } - if (n == 1) { + if (j == 1) { return str; } else { throw new ArrayIndexOutOfBoundsException(); } } - private void buildLookupTable(Node n) { - for (Node child : n.getChildren()) { + private void buildLookupTable(final Node n) { + for (final Node child : n.getChildren()) { lookupTable.put(child.getFullName(), child); buildLookupTable(child); } @@ -329,23 +328,23 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { final ClassNode iface; try { iface = (ClassNode) getNode(n.getFullName()); - } catch (NameResolutionException e) { + } catch (final NameResolutionException e) { throw new IllegalStateException("When reading protocol buffer node " + n.getFullName() + " does not exist. Full record is " + n, e); } - for (String impl : cn.getImplFullNamesList()) { + for (final String impl : cn.getImplFullNamesList()) { try { iface.putImpl((ClassNode) getNode(impl)); - } catch (NameResolutionException e) { + } catch (final NameResolutionException e) { throw new IllegalStateException("When reading protocol buffer node " + n + " refers to non-existent implementation:" + impl); - } catch (ClassCastException e) { + } catch (final ClassCastException e) { try { throw new IllegalStateException( "When reading protocol buffer node " + n + " found implementation" + getNode(impl) + " which is not a ClassNode!"); - } catch (NameResolutionException e2) { + } catch (final NameResolutionException e2) { throw new IllegalStateException( "Got 'cant happen' exception when producing error message for " + e); @@ -354,15 +353,15 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { } } - for (ClassHierarchyProto.Node child : n.getChildrenList()) { + for (final ClassHierarchyProto.Node child : n.getChildrenList()) { wireUpInheritanceRelationships(child); } } @Override - public Node getNode(String fullName) throws NameResolutionException { + public Node getNode(final String fullName) throws NameResolutionException { - Node ret = lookupTable.get(fullName); + final Node ret = lookupTable.get(fullName); if (ret != null) { return ret; } else { @@ -371,12 +370,12 @@ public class ProtocolBufferClassHierarchy implements ClassHierarchy { } @Override - public boolean isImplementation(ClassNode<?> inter, ClassNode<?> impl) { + public boolean isImplementation(final ClassNode<?> inter, final ClassNode<?> impl) { return impl.isImplementationOf(inter); } @Override - public ClassHierarchy merge(ClassHierarchy ch) { + public ClassHierarchy merge(final ClassHierarchy ch) { if (this == ch) { return this; } http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferInjectionPlan.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferInjectionPlan.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferInjectionPlan.java index 4caf3f5..0a6132c 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferInjectionPlan.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/protobuf/ProtocolBufferInjectionPlan.java @@ -36,7 +36,7 @@ import java.util.List; public class ProtocolBufferInjectionPlan { <T> InjectionPlanProto.InjectionPlan newConstructor(final String fullName, - List<InjectionPlanProto.InjectionPlan> plans) { + final List<InjectionPlanProto.InjectionPlan> plans) { return InjectionPlanProto.InjectionPlan .newBuilder() .setName(fullName) @@ -46,7 +46,8 @@ public class ProtocolBufferInjectionPlan { } <T> InjectionPlanProto.InjectionPlan newSubplan(final String fullName, - int selectedPlan, List<InjectionPlanProto.InjectionPlan> plans) { + final int selectedPlan, + final List<InjectionPlanProto.InjectionPlan> plans) { return InjectionPlanProto.InjectionPlan .newBuilder() .setName(fullName) @@ -63,27 +64,27 @@ public class ProtocolBufferInjectionPlan { .build(); } - public <T> InjectionPlanProto.InjectionPlan serialize(InjectionPlan<T> ip) { + public <T> InjectionPlanProto.InjectionPlan serialize(final InjectionPlan<T> ip) { if (ip instanceof Constructor) { - Constructor<T> cons = (Constructor<T>) ip; - InjectionPlan<?>[] args = cons.getArgs(); - InjectionPlanProto.InjectionPlan[] protoArgs = new InjectionPlanProto.InjectionPlan[args.length]; + final Constructor<T> cons = (Constructor<T>) ip; + final InjectionPlan<?>[] args = cons.getArgs(); + final InjectionPlanProto.InjectionPlan[] protoArgs = new InjectionPlanProto.InjectionPlan[args.length]; for (int i = 0; i < args.length; i++) { protoArgs[i] = serialize(args[i]); } return newConstructor(ip.getNode().getFullName(), Arrays.asList(protoArgs)); } else if (ip instanceof Subplan) { - Subplan<T> sp = (Subplan<T>) ip; - InjectionPlan<?>[] args = sp.getPlans(); - InjectionPlanProto.InjectionPlan[] subPlans = new InjectionPlanProto.InjectionPlan[args.length]; + final Subplan<T> sp = (Subplan<T>) ip; + final InjectionPlan<?>[] args = sp.getPlans(); + final InjectionPlanProto.InjectionPlan[] subPlans = new InjectionPlanProto.InjectionPlan[args.length]; for (int i = 0; i < args.length; i++) { subPlans[i] = serialize(args[i]); } return newSubplan(ip.getNode().getFullName(), sp.getSelectedIndex(), Arrays.asList(subPlans)); } else if (ip instanceof JavaInstance) { - JavaInstance<T> ji = (JavaInstance<T>) ip; + final JavaInstance<T> ji = (JavaInstance<T>) ip; return newInstance(ip.getNode().getFullName(), ji.getInstanceAsString()); } else { throw new IllegalStateException( @@ -91,7 +92,7 @@ public class ProtocolBufferInjectionPlan { } } - private Object parse(String type, String value) { + private Object parse(final String type, final String value) { // XXX this is a placeholder for now. We need a parser API that will // either produce a live java object or (partially) validate stuff to // see if it looks like the target language will be able to handle this @@ -100,8 +101,8 @@ public class ProtocolBufferInjectionPlan { } @SuppressWarnings("unchecked") - public <T> InjectionPlan<T> deserialize(ClassHierarchy ch, - InjectionPlanProto.InjectionPlan ip) throws NameResolutionException, + public <T> InjectionPlan<T> deserialize(final ClassHierarchy ch, + final InjectionPlanProto.InjectionPlan ip) throws NameResolutionException, BindException { final String fullName = ip.getName(); if (ip.hasConstructor()) { @@ -126,8 +127,8 @@ public class ProtocolBufferInjectionPlan { final ConstructorDef<T> constructor = cn.getConstructorDef(cnArgs); return new Constructor<T>(cn, constructor, ipArgs); } else if (ip.hasInstance()) { - InjectionPlanProto.Instance ins = ip.getInstance(); - T instance = (T) parse(ip.getName(), ins.getValue()); + final InjectionPlanProto.Instance ins = ip.getInstance(); + final T instance = (T) parse(ip.getName(), ins.getValue()); return new JavaInstance<T>(ch.getNode(ip.getName()), instance); } else if (ip.hasSubplan()) { final InjectionPlanProto.Subplan subplan = ip.getSubplan(); @@ -138,7 +139,7 @@ public class ProtocolBufferInjectionPlan { for (int i = 0; i < protoBufPlans.length; i++) { subPlans[i] = (InjectionPlan<T>) deserialize(ch, protoBufPlans[i]); } - Node n = ch.getNode(fullName); + final Node n = ch.getNode(fullName); return new Subplan<T>(n, subPlans); } else { throw new IllegalStateException( http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/AbstractNode.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/AbstractNode.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/AbstractNode.java index e706491..9262bea 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/AbstractNode.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/AbstractNode.java @@ -30,7 +30,7 @@ public abstract class AbstractNode implements Node { private final String name; private final String fullName; - public AbstractNode(Node parent, String name, String fullName) { + public AbstractNode(final Node parent, final String name, final String fullName) { this.parent = parent; this.name = name; this.fullName = fullName; @@ -54,7 +54,7 @@ public abstract class AbstractNode implements Node { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (o == null) { return false; } @@ -62,7 +62,7 @@ public abstract class AbstractNode implements Node { return true; } - AbstractNode n = (AbstractNode) o; + final AbstractNode n = (AbstractNode) o; final boolean parentsEqual; if (n.parent == this.parent) { parentsEqual = true; @@ -90,29 +90,29 @@ public abstract class AbstractNode implements Node { } @Override - public boolean contains(String key) { + public boolean contains(final String key) { return children.containsKey(key); } @Override - public Node get(String key) { + public Node get(final String key) { return children.get(key); } @Override - public void put(Node n) { + public void put(final Node n) { children.put(n.getName(), n); } @SuppressWarnings("unused") - private String toIndentedString(int level) { - StringBuilder sb = new StringBuilder(); + private String toIndentedString(final int level) { + final StringBuilder sb = new StringBuilder(); for (int i = 0; i < level; i++) { sb.append("\t"); } sb.append(toString() + "\n"); if (children != null) { - for (Node n : children.values()) { + for (final Node n : children.values()) { sb.append(((AbstractNode) n).toIndentedString(level + 1)); } } @@ -130,7 +130,7 @@ public abstract class AbstractNode implements Node { } @Override - public int compareTo(Node n) { + public int compareTo(final Node n) { return getFullName().compareTo(n.getFullName()); } } http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ClassNodeImpl.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ClassNodeImpl.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ClassNodeImpl.java index 75ca7fc..0e8a1d8 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ClassNodeImpl.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ClassNodeImpl.java @@ -37,11 +37,11 @@ public class ClassNodeImpl<T> extends AbstractNode implements ClassNode<T> { private final MonotonicSet<ClassNode<T>> knownImpls; private final String defaultImpl; - public ClassNodeImpl(Node parent, String simpleName, String fullName, - boolean unit, boolean injectable, boolean externalConstructor, - ConstructorDef<T>[] injectableConstructors, - ConstructorDef<T>[] allConstructors, - String defaultImplementation) { + public ClassNodeImpl(final Node parent, final String simpleName, final String fullName, + final boolean unit, final boolean injectable, final boolean externalConstructor, + final ConstructorDef<T>[] injectableConstructors, + final ConstructorDef<T>[] allConstructors, + final String defaultImplementation) { super(parent, simpleName, fullName); this.unit = unit; this.injectable = injectable; @@ -74,9 +74,9 @@ public class ClassNodeImpl<T> extends AbstractNode implements ClassNode<T> { @Override public String toString() { - StringBuilder sb = new StringBuilder(super.toString() + ": "); + final StringBuilder sb = new StringBuilder(super.toString() + ": "); if (getInjectableConstructors() != null) { - for (ConstructorDef<T> c : getInjectableConstructors()) { + for (final ConstructorDef<T> c : getInjectableConstructors()) { sb.append(c.toString() + ", "); } } else { @@ -85,13 +85,13 @@ public class ClassNodeImpl<T> extends AbstractNode implements ClassNode<T> { return sb.toString(); } - public ConstructorDef<T> getConstructorDef(ClassNode<?>... paramTypes) + public ConstructorDef<T> getConstructorDef(final ClassNode<?>... paramTypes) throws BindException { if (!isInjectionCandidate()) { throw new BindException("Cannot @Inject non-static member/local class: " + getFullName()); } - for (ConstructorDef<T> c : getAllConstructors()) { + for (final ConstructorDef<T> c : getAllConstructors()) { if (c.takesParameters(paramTypes)) { return c; } @@ -101,7 +101,7 @@ public class ClassNodeImpl<T> extends AbstractNode implements ClassNode<T> { } @Override - public void putImpl(ClassNode<T> impl) { + public void putImpl(final ClassNode<T> impl) { knownImpls.add(impl); } @@ -116,15 +116,15 @@ public class ClassNodeImpl<T> extends AbstractNode implements ClassNode<T> { } @Override - public boolean isImplementationOf(ClassNode<?> inter) { - List<ClassNode<?>> worklist = new ArrayList<>(); + public boolean isImplementationOf(final ClassNode<?> inter) { + final List<ClassNode<?>> worklist = new ArrayList<>(); if (this.equals(inter)) { return true; } worklist.add(inter); while (!worklist.isEmpty()) { - ClassNode<?> cn = worklist.remove(worklist.size() - 1); - @SuppressWarnings({"rawtypes", "unchecked"}) + final ClassNode<?> cn = worklist.remove(worklist.size() - 1); + @SuppressWarnings({"rawtypes", "unchecked"}) final Set<ClassNode<?>> impls = (Set) cn.getKnownImplementations(); if (impls.contains(this)) { return true; http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorArgImpl.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorArgImpl.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorArgImpl.java index 7297817..803875f 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorArgImpl.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorArgImpl.java @@ -25,7 +25,7 @@ public class ConstructorArgImpl implements ConstructorArg { private final String name; private final boolean isInjectionFuture; - public ConstructorArgImpl(String type, String namedParameterName, boolean isInjectionFuture) { + public ConstructorArgImpl(final String type, final String namedParameterName, final boolean isInjectionFuture) { this.type = type; this.name = namedParameterName; this.isInjectionFuture = isInjectionFuture; @@ -52,8 +52,8 @@ public class ConstructorArgImpl implements ConstructorArg { } @Override - public boolean equals(Object o) { - ConstructorArgImpl arg = (ConstructorArgImpl) o; + public boolean equals(final Object o) { + final ConstructorArgImpl arg = (ConstructorArgImpl) o; if (!type.equals(arg.type)) { return false; } http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorDefImpl.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorDefImpl.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorDefImpl.java index ef3ff9e..c2ac2fd 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorDefImpl.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/ConstructorDefImpl.java @@ -29,8 +29,8 @@ public class ConstructorDefImpl<T> implements ConstructorDef<T> { private final ConstructorArg[] args; private final String className; - public ConstructorDefImpl(String className, ConstructorArg[] args, - boolean injectable) throws ClassHierarchyException { + public ConstructorDefImpl(final String className, final ConstructorArg[] args, + final boolean injectable) throws ClassHierarchyException { this.className = className; this.args = args; if (injectable) { @@ -56,9 +56,9 @@ public class ConstructorDefImpl<T> implements ConstructorDef<T> { return className; } - private String join(String sep, Object[] vals) { + private String join(final String sep, final Object[] vals) { if (vals.length != 0) { - StringBuilder sb = new StringBuilder(vals[0].toString()); + final StringBuilder sb = new StringBuilder(vals[0].toString()); for (int i = 1; i < vals.length; i++) { sb.append(sep + vals[i]); } @@ -70,7 +70,7 @@ public class ConstructorDefImpl<T> implements ConstructorDef<T> { @Override public String toString() { - StringBuilder sb = new StringBuilder(className); + final StringBuilder sb = new StringBuilder(className); sb.append("("); sb.append(join(",", args)); sb.append(")"); @@ -78,7 +78,7 @@ public class ConstructorDefImpl<T> implements ConstructorDef<T> { } @Override - public boolean takesParameters(ClassNode<?>[] paramTypes) { + public boolean takesParameters(final ClassNode<?>[] paramTypes) { if (paramTypes.length != args.length) { return false; } @@ -100,7 +100,7 @@ public class ConstructorDefImpl<T> implements ConstructorDef<T> { * @param def * @return */ - private boolean equalsIgnoreOrder(ConstructorDef<?> def) { + private boolean equalsIgnoreOrder(final ConstructorDef<?> def) { if (getArgs().length != def.getArgs().length) { return false; } @@ -119,12 +119,12 @@ public class ConstructorDefImpl<T> implements ConstructorDef<T> { } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { return equalsIgnoreOrder((ConstructorDef<?>) o); } @Override - public boolean isMoreSpecificThan(ConstructorDef<?> def) { + public boolean isMoreSpecificThan(final ConstructorDef<?> def) { // Return true if our list of args is a superset of those in def. // Is everything in def also in this? @@ -147,13 +147,13 @@ public class ConstructorDefImpl<T> implements ConstructorDef<T> { } @Override - public int compareTo(ConstructorDef<?> o) { + public int compareTo(final ConstructorDef<?> o) { return toString().compareTo(o.toString()); } @Override public int hashCode() { - ConstructorArg[] argsSort = getArgs().clone(); + final ConstructorArg[] argsSort = getArgs().clone(); Arrays.sort(argsSort); return Arrays.hashCode(argsSort); } http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/NamedParameterNodeImpl.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/NamedParameterNodeImpl.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/NamedParameterNodeImpl.java index f25781e..fea5dd2 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/NamedParameterNodeImpl.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/NamedParameterNodeImpl.java @@ -31,10 +31,11 @@ public class NamedParameterNodeImpl<T> extends AbstractNode implements private final boolean isSet; private final boolean isList; - public NamedParameterNodeImpl(Node parent, String simpleName, - String fullName, String fullArgName, String simpleArgName, - boolean isSet, boolean isList, - String documentation, String shortName, String[] defaultInstanceAsStrings) { + public NamedParameterNodeImpl(final Node parent, final String simpleName, + final String fullName, final String fullArgName, final String simpleArgName, + final boolean isSet, final boolean isList, + final String documentation, final String shortName, + final String[] defaultInstanceAsStrings) { super(parent, simpleName, fullName); this.fullArgName = fullArgName; this.simpleArgName = simpleArgName; http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/PackageNodeImpl.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/PackageNodeImpl.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/PackageNodeImpl.java index 4ed8ffb..ef2194f 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/PackageNodeImpl.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/implementation/types/PackageNodeImpl.java @@ -22,7 +22,7 @@ import org.apache.reef.tang.types.Node; import org.apache.reef.tang.types.PackageNode; public class PackageNodeImpl extends AbstractNode implements PackageNode { - public PackageNodeImpl(Node parent, String name, String fullName) { + public PackageNodeImpl(final Node parent, final String name, final String fullName) { super(parent, name, fullName); } @@ -36,7 +36,7 @@ public class PackageNodeImpl extends AbstractNode implements PackageNode { * we insert nodes into the root. */ @Override - public void put(Node n) { + public void put(final Node n) { super.children.put(n.getFullName(), n); } http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/AbstractMonotonicMultiMap.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/AbstractMonotonicMultiMap.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/AbstractMonotonicMultiMap.java index 884ccd6..c044654 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/AbstractMonotonicMultiMap.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/AbstractMonotonicMultiMap.java @@ -25,11 +25,11 @@ public abstract class AbstractMonotonicMultiMap<K, V> implements Collection<Entr protected Map<K, Set<V>> map; private int size = 0; - public AbstractMonotonicMultiMap(Map<K, Set<V>> map) { + public AbstractMonotonicMultiMap(final Map<K, Set<V>> map) { this.map = map; } - public void put(K key, V v) { + public void put(final K key, final V v) { Set<V> vals = map.get(key); if (vals == null) { vals = new MonotonicHashSet<V>(); @@ -43,8 +43,8 @@ public abstract class AbstractMonotonicMultiMap<K, V> implements Collection<Entr return map.keySet(); } - public Set<V> getValuesForKey(K key) { - Set<V> ret = map.get(key); + public Set<V> getValuesForKey(final K key) { + final Set<V> ret = map.get(key); if (ret == null) { return new MonotonicHashSet<V>(); } else { @@ -52,8 +52,8 @@ public abstract class AbstractMonotonicMultiMap<K, V> implements Collection<Entr } } - public boolean contains(K key, V v) { - Set<V> vals = map.get(key); + public boolean contains(final K key, final V v) { + final Set<V> vals = map.get(key); if (vals != null) { return vals.contains(v); } @@ -61,15 +61,15 @@ public abstract class AbstractMonotonicMultiMap<K, V> implements Collection<Entr } @Override - public boolean add(Entry<K, V> e) { + public boolean add(final Entry<K, V> e) { put(e.getKey(), e.getValue()); return true; } @Override - public boolean addAll(Collection<? extends Entry<K, V>> c) { + public boolean addAll(final Collection<? extends Entry<K, V>> c) { boolean ret = false; - for (Entry<K, V> e : c) { + for (final Entry<K, V> e : c) { add(e); ret = true; } @@ -83,14 +83,14 @@ public abstract class AbstractMonotonicMultiMap<K, V> implements Collection<Entr @SuppressWarnings("unchecked") @Override - public boolean contains(Object o) { - Entry<?, ?> e = (Entry<?, ?>) o; + public boolean contains(final Object o) { + final Entry<?, ?> e = (Entry<?, ?>) o; return contains((K) e.getKey(), (V) e.getValue()); } @Override - public boolean containsAll(Collection<?> c) { - for (Object o : c) { + public boolean containsAll(final Collection<?> c) { + for (final Object o : c) { if (!contains(o)) { return false; } @@ -119,7 +119,7 @@ public abstract class AbstractMonotonicMultiMap<K, V> implements Collection<Entr public Entry<K, V> next() { if (cur == null) { if (it.hasNext()) { - Entry<K, Set<V>> e = it.next(); + final Entry<K, Set<V>> e = it.next(); curKey = e.getKey(); cur = e.getValue().iterator(); } @@ -143,7 +143,7 @@ public abstract class AbstractMonotonicMultiMap<K, V> implements Collection<Entr } @Override - public V setValue(V value) { + public V setValue(final V value) { throw new UnsupportedOperationException(); } @@ -159,25 +159,25 @@ public abstract class AbstractMonotonicMultiMap<K, V> implements Collection<Entr } public Set<V> values() { - Set<V> s = new HashSet<>(); - for (Entry<K, V> e : this) { + final Set<V> s = new HashSet<>(); + for (final Entry<K, V> e : this) { s.add(e.getValue()); } return s; } @Override - public boolean remove(Object o) { + public boolean remove(final Object o) { throw new UnsupportedOperationException("MonotonicMultiMap does not support non-monotonic method remove!"); } @Override - public boolean removeAll(Collection<?> c) { + public boolean removeAll(final Collection<?> c) { throw new UnsupportedOperationException("MonotonicMultiMap does not support non-monotonic method removeAll!"); } @Override - public boolean retainAll(Collection<?> c) { + public boolean retainAll(final Collection<?> c) { throw new UnsupportedOperationException("MonotonicMultiMap does not support non-monotonic method retainAll!"); } @@ -192,11 +192,11 @@ public abstract class AbstractMonotonicMultiMap<K, V> implements Collection<Entr } @Override - public <T> T[] toArray(T[] a) { + public <T> T[] toArray(final T[] a) { throw new UnsupportedOperationException("No toArray() for MonotonicMulitMap (yet)"); } - public boolean containsKey(K k) { + public boolean containsKey(final K k) { if (map.containsKey(k)) { return !getValuesForKey(k).isEmpty(); } else { http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashMap.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashMap.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashMap.java index 5e99a28..f6fb1ab 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashMap.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashMap.java @@ -25,8 +25,8 @@ public class MonotonicHashMap<T, U> extends HashMap<T, U> { private static final long serialVersionUID = 1L; @Override - public U put(T key, U value) { - U old = super.get(key); + public U put(final T key, final U value) { + final U old = super.get(key); if (old != null) { throw new IllegalArgumentException("Attempt to re-add: [" + key + "] old value: " + old + " new value " + value); @@ -35,13 +35,13 @@ public class MonotonicHashMap<T, U> extends HashMap<T, U> { } @Override - public void putAll(Map<? extends T, ? extends U> m) { - for (T t : m.keySet()) { + public void putAll(final Map<? extends T, ? extends U> m) { + for (final T t : m.keySet()) { if (containsKey(t)) { put(t, m.get(t)); // guaranteed to throw. } } - for (T t : m.keySet()) { + for (final T t : m.keySet()) { put(t, m.get(t)); } } @@ -52,7 +52,7 @@ public class MonotonicHashMap<T, U> extends HashMap<T, U> { } @Override - public U remove(Object o) { + public U remove(final Object o) { throw new UnsupportedOperationException(); } } http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashSet.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashSet.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashSet.java index 8c746ab..6a322c1 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashSet.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicHashSet.java @@ -29,17 +29,17 @@ public class MonotonicHashSet<T> extends HashSet<T> { super(); } - public MonotonicHashSet(Collection<T> c) { + public MonotonicHashSet(final Collection<T> c) { super(c); } @SafeVarargs - public MonotonicHashSet(T... c) { + public MonotonicHashSet(final T... c) { super(Arrays.asList(c)); } @Override - public boolean add(T e) { + public boolean add(final T e) { if (super.contains(e)) { throw new IllegalArgumentException("Attempt to re-add " + e + " to MonotonicSet!"); @@ -53,34 +53,34 @@ public class MonotonicHashSet<T> extends HashSet<T> { } @Override - public boolean remove(Object o) { + public boolean remove(final Object o) { throw new UnsupportedOperationException("Attempt to remove " + o + " from MonotonicSet!"); } @Override - public boolean removeAll(Collection<?> c) { + public boolean removeAll(final Collection<?> c) { throw new UnsupportedOperationException( "removeAll() doesn't make sense for MonotonicSet!"); } @Override - public boolean retainAll(Collection<?> c) { + public boolean retainAll(final Collection<?> c) { throw new UnsupportedOperationException( "retainAll() doesn't make sense for MonotonicSet!"); } @Override - public boolean addAll(Collection<? extends T> c) { - for (T t : c) { + public boolean addAll(final Collection<? extends T> c) { + for (final T t : c) { add(t); } return c.size() != 0; } - public boolean addAllIgnoreDuplicates(Collection<? extends T> c) { + public boolean addAllIgnoreDuplicates(final Collection<? extends T> c) { boolean ret = false; - for (T t : c) { + for (final T t : c) { if (!contains(t)) { add(t); ret = true; http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicSet.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicSet.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicSet.java index 6d96186..59360a0 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicSet.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicSet.java @@ -29,17 +29,17 @@ public class MonotonicSet<T> extends TreeSet<T> { super(); } - public MonotonicSet(TreeSet<T> c) { + public MonotonicSet(final TreeSet<T> c) { super(c.comparator()); addAll(c); } - public MonotonicSet(Comparator<T> c) { + public MonotonicSet(final Comparator<T> c) { super(c); } @Override - public boolean add(T e) { + public boolean add(final T e) { if (super.contains(e)) { throw new IllegalArgumentException("Attempt to re-add " + e + " to MonotonicSet!"); @@ -53,34 +53,34 @@ public class MonotonicSet<T> extends TreeSet<T> { } @Override - public boolean remove(Object o) { + public boolean remove(final Object o) { throw new UnsupportedOperationException("Attempt to remove " + o + " from MonotonicSet!"); } @Override - public boolean removeAll(Collection<?> c) { + public boolean removeAll(final Collection<?> c) { throw new UnsupportedOperationException( "removeAll() doesn't make sense for MonotonicSet!"); } @Override - public boolean retainAll(Collection<?> c) { + public boolean retainAll(final Collection<?> c) { throw new UnsupportedOperationException( "retainAll() doesn't make sense for MonotonicSet!"); } @Override - public boolean addAll(Collection<? extends T> c) { - for (T t : c) { + public boolean addAll(final Collection<? extends T> c) { + for (final T t : c) { add(t); } return c.size() != 0; } - public boolean addAllIgnoreDuplicates(Collection<? extends T> c) { + public boolean addAllIgnoreDuplicates(final Collection<? extends T> c) { boolean ret = false; - for (T t : c) { + for (final T t : c) { if (!contains(t)) { add(t); ret = true; http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicTreeMap.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicTreeMap.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicTreeMap.java index 3a353f0..52d4622 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicTreeMap.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/MonotonicTreeMap.java @@ -55,8 +55,8 @@ public final class MonotonicTreeMap<T, U> implements Map<T, U> { } @Override - public U put(T key, U value) { - U old = innerMap.get(key); + public U put(final T key, final U value) { + final U old = innerMap.get(key); if (old != null) { throw new IllegalArgumentException("Attempt to re-add: [" + key + "]\n old value: " + old + " new value " + value); @@ -65,7 +65,7 @@ public final class MonotonicTreeMap<T, U> implements Map<T, U> { } @Override - public void putAll(Map<? extends T, ? extends U> m) { + public void putAll(final Map<? extends T, ? extends U> m) { throw new UnsupportedOperationException(); } @@ -90,12 +90,12 @@ public final class MonotonicTreeMap<T, U> implements Map<T, U> { } @Override - public U remove(Object o) { + public U remove(final Object o) { throw new UnsupportedOperationException(); } @Override - public boolean equals(Object o) { + public boolean equals(final Object o) { if (this == o) { return true; } http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/141c7fa0/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/ReflectionUtilities.java ---------------------------------------------------------------------- diff --git a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/ReflectionUtilities.java b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/ReflectionUtilities.java index 5275627..a91e18e 100644 --- a/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/ReflectionUtilities.java +++ b/lang/java/reef-tang/tang/src/main/java/org/apache/reef/tang/util/ReflectionUtilities.java @@ -64,7 +64,7 @@ public final class ReflectionUtilities { * @param c The class to be boxed. * @return The boxed version of c, or c if it is not a primitive type. */ - public static Class<?> boxClass(Class<?> c) { + public static Class<?> boxClass(final Class<?> c) { if (c.isPrimitive() && c != Class.class) { if (c == boolean.class) { return Boolean.class; @@ -103,26 +103,27 @@ public final class ReflectionUtilities { * HashSet<T> -> {HashSet<T>, Set<T>, Collection<T>, Object} * FooEventHandler -> {FooEventHandler, EventHandler<Foo>, Object} */ - public static Iterable<Type> classAndAncestors(Type c) { - List<Type> workQueue = new ArrayList<>(); + public static Iterable<Type> classAndAncestors(final Type c) { + final List<Type> workQueue = new ArrayList<>(); - workQueue.add(c); - if (getRawClass(c).isInterface()) { + Type clazz = c; + workQueue.add(clazz); + if (getRawClass(clazz).isInterface()) { workQueue.add(Object.class); } for (int i = 0; i < workQueue.size(); i++) { - c = workQueue.get(i); + clazz = workQueue.get(i); - if (c instanceof Class) { - Class<?> clz = (Class<?>) c; + if (clazz instanceof Class) { + final Class<?> clz = (Class<?>) clazz; final Type sc = clz.getSuperclass(); if (sc != null) { workQueue.add(sc); //c.getSuperclass()); } workQueue.addAll(Arrays.asList(clz.getGenericInterfaces())); - } else if (c instanceof ParameterizedType) { - ParameterizedType pt = (ParameterizedType) c; - Class<?> rawPt = (Class<?>) pt.getRawType(); + } else if (clazz instanceof ParameterizedType) { + final ParameterizedType pt = (ParameterizedType) clazz; + final Class<?> rawPt = (Class<?>) pt.getRawType(); final Type sc = rawPt.getSuperclass(); // workQueue.add(pt); // workQueue.add(rawPt); @@ -130,12 +131,12 @@ public final class ReflectionUtilities { workQueue.add(sc); } workQueue.addAll(Arrays.asList(rawPt.getGenericInterfaces())); - } else if (c instanceof WildcardType) { + } else if (clazz instanceof WildcardType) { workQueue.add(Object.class); // XXX not really correct, but close enough? - } else if (c instanceof TypeVariable) { + } else if (clazz instanceof TypeVariable) { workQueue.add(Object.class); // XXX not really correct, but close enough? } else { - throw new RuntimeException(c.getClass() + " " + c + " is of unknown type!"); + throw new RuntimeException(clazz.getClass() + " " + clazz + " is of unknown type!"); } } return workQueue; @@ -151,14 +152,14 @@ public final class ReflectionUtilities { * <p/> * TODO: Float and double are currently coercible to int and long. This is a bug. */ - public static boolean isCoercable(Class<?> to, Class<?> from) { - to = boxClass(to); - from = boxClass(from); - if (Number.class.isAssignableFrom(to) - && Number.class.isAssignableFrom(from)) { - return SIZEOF.get(from) <= SIZEOF.get(to); + public static boolean isCoercable(final Class<?> to, final Class<?> from) { + final Class<?> boxedTo = boxClass(to); + final Class<?> boxedFrom = boxClass(from); + if (Number.class.isAssignableFrom(boxedTo) + && Number.class.isAssignableFrom(boxedFrom)) { + return SIZEOF.get(boxedFrom) <= SIZEOF.get(boxedTo); } - return to.isAssignableFrom(from); + return boxedTo.isAssignableFrom(boxedFrom); } /** @@ -168,7 +169,7 @@ public final class ReflectionUtilities { * * @throws ClassNotFoundException */ - public static Class<?> classForName(String name, ClassLoader loader) + public static Class<?> classForName(final String name, final ClassLoader loader) throws ClassNotFoundException { if (name.startsWith("[")) { throw new UnsupportedOperationException("No support for arrays, etc. Name was: " + name); @@ -204,7 +205,7 @@ public final class ReflectionUtilities { * @param name * @return */ - public static String getSimpleName(Type name) { + public static String getSimpleName(final Type name) { final Class<?> clazz = getRawClass(name); final String[] nameArray = clazz.getName().split(REGEXP); final String ret = nameArray[nameArray.length - 1]; @@ -225,7 +226,7 @@ public final class ReflectionUtilities { * @param name * @return */ - public static String getFullName(Type name) { + public static String getFullName(final Type name) { return getRawClass(name).getName(); } @@ -238,7 +239,7 @@ public final class ReflectionUtilities { * <p/> * Set<X> { int size; } -> java.util.Set.size */ - public static String getFullName(Field f) { + public static String getFullName(final Field f) { return getFullName(f.getDeclaringClass()) + "." + f.getName(); } @@ -259,7 +260,7 @@ public final class ReflectionUtilities { if (type instanceof ParameterizedType) { final ParameterizedType pt = (ParameterizedType) type; if (iface.isAssignableFrom((Class<?>) pt.getRawType())) { - Type t = pt.getActualTypeArguments()[0]; + final Type t = pt.getActualTypeArguments()[0]; return t; } else { throw new IllegalArgumentException("Parameterized type " + type + " does not extend " + iface); @@ -271,20 +272,20 @@ public final class ReflectionUtilities { throw new IllegalArgumentException(); } - ArrayList<Type> al = new ArrayList<>(); + final ArrayList<Type> al = new ArrayList<>(); al.addAll(Arrays.asList(clazz.getGenericInterfaces())); - Type sc = clazz.getGenericSuperclass(); + final Type sc = clazz.getGenericSuperclass(); if (sc != null) { al.add(sc); } final Type[] interfaces = al.toArray(new Type[0]); - for (Type genericNameType : interfaces) { + for (final Type genericNameType : interfaces) { if (genericNameType instanceof ParameterizedType) { - ParameterizedType ptype = (ParameterizedType) genericNameType; + final ParameterizedType ptype = (ParameterizedType) genericNameType; if (ptype.getRawType().equals(iface)) { - Type t = ptype.getActualTypeArguments()[0]; + final Type t = ptype.getActualTypeArguments()[0]; return t; } } @@ -301,22 +302,22 @@ public final class ReflectionUtilities { * @throws org.apache.reef.tang.exceptions.BindException * If clazz's definition incorrectly uses Name or @NamedParameter */ - public static Type getNamedParameterTargetOrNull(Class<?> clazz) + public static Type getNamedParameterTargetOrNull(final Class<?> clazz) throws ClassHierarchyException { - Annotation npAnnotation = clazz.getAnnotation(NamedParameter.class); - boolean hasSuperClass = (clazz.getSuperclass() != Object.class); + final Annotation npAnnotation = clazz.getAnnotation(NamedParameter.class); + final boolean hasSuperClass = (clazz.getSuperclass() != Object.class); boolean isInjectable = false; boolean hasConstructor = false; // TODO Figure out how to properly differentiate between default and // non-default zero-arg constructors? - Constructor<?>[] constructors = clazz.getDeclaredConstructors(); + final Constructor<?>[] constructors = clazz.getDeclaredConstructors(); if (constructors.length > 1) { hasConstructor = true; } if (constructors.length == 1) { - Constructor<?> c = constructors[0]; - Class<?>[] p = c.getParameterTypes(); + final Constructor<?> c = constructors[0]; + final Class<?>[] p = c.getParameterTypes(); if (p.length > 1) { // Multiple args. Definitely not implicit. hasConstructor = true; @@ -329,23 +330,23 @@ public final class ReflectionUtilities { } } } - for (Constructor<?> c : constructors) { - for (Annotation a : c.getDeclaredAnnotations()) { + for (final Constructor<?> c : constructors) { + for (final Annotation a : c.getDeclaredAnnotations()) { if (a instanceof Inject) { isInjectable = true; } } } - Class<?>[] allInterfaces = clazz.getInterfaces(); + final Class<?>[] allInterfaces = clazz.getInterfaces(); - boolean hasMultipleInterfaces = (allInterfaces.length > 1); + final boolean hasMultipleInterfaces = (allInterfaces.length > 1); boolean implementsName; Type parameterClass = null; try { parameterClass = getInterfaceTarget(Name.class, clazz); implementsName = true; - } catch (IllegalArgumentException e) { + } catch (final IllegalArgumentException e) { implementsName = false; } @@ -394,7 +395,7 @@ public final class ReflectionUtilities { * T -> Object * ? -> Object */ - public static Class<?> getRawClass(Type clazz) { + public static Class<?> getRawClass(final Type clazz) { if (clazz instanceof Class) { return (Class<?>) clazz; } else if (clazz instanceof ParameterizedType) {
