cleanup

Author: burtbeckwith

src/java/org/codehaus/groovy/grails/commons/AbstractGrailsClass.java

@@ -1,45 +1,43 @@
 /*
  * Copyright 2004-2005 the original author or authors.
- * 
+ *
  * 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.codehaus.groovy.grails.commons;
+
 /**
  * Configures Grails classe to be autowirable by name, always.
- * 
+ *
  * @author Graeme Rocher
  * @author Steven Devijver
- * 
+ *
  * @since 0.1
- * 
- *  Created: Jul 2, 2005
  */
-public abstract class AbstractInjectableGrailsClass extends AbstractGrailsClass
-		implements InjectableGrailsClass {
+public abstract class AbstractInjectableGrailsClass extends AbstractGrailsClass implements InjectableGrailsClass {
+
+    public AbstractInjectableGrailsClass(Class<?> clazz, String trailingName) {
+        super(clazz, trailingName);
+    }
 
-	public AbstractInjectableGrailsClass(Class clazz, String trailingName) {
-		super(clazz, trailingName);
-	}
+    public boolean byName() {
+        return true;
+    }
 
-	public boolean byName() {
-		return true;
-	}
+    public boolean byType() {
+        return false;
+    }
 
-	public boolean byType() {
-		return false;
-	}
-	
-	public boolean getAvailable() {
-		return true;
-	}
+    public boolean getAvailable() {
+        return true;
+    }
 }

src/java/org/codehaus/groovy/grails/commons/AbstractInjectableGrailsClass.java

@@ -14,19 +14,19 @@
  */
 package org.codehaus.groovy.grails.commons;
 
-import javax.persistence.Entity;
 import java.util.HashSet;
 import java.util.Set;
 
+import javax.persistence.Entity;
+
 /**
- * Detects annotated domain classes for EJB3 style mappings
+ * Detects annotated domain classes for EJB3 style mappings.
  *
  * @author Graeme Rocher
  * @since 1.0
- *        <p/>
- *        Created: Dec 6, 2007
  */
 public class AnnotationDomainClassArtefactHandler extends DomainClassArtefactHandler{
+
     private static final String JPA_MAPPING_STRATEGY = "JPA";
 
     private Set<String> jpaClassNames = new HashSet<String>();
@@ -35,22 +35,25 @@ public Set<String> getJpaClassNames() {
         return jpaClassNames;
     }
 
-    public boolean isArtefactClass(Class clazz) {
+    @Override
+    public boolean isArtefactClass(@SuppressWarnings("unchecked") Class clazz) {
         final boolean isJpaDomainClass = isJPADomainClass(clazz);
-        if(isJpaDomainClass) {
-             jpaClassNames.add(clazz.getName());
+        if (isJpaDomainClass) {
+            jpaClassNames.add(clazz.getName());
         }
         return super.isArtefactClass(clazz) ;
     }
 
-    public static boolean isJPADomainClass(Class clazz){
+    public static boolean isJPADomainClass(Class <?>clazz){
         return clazz != null && clazz.getAnnotation(Entity.class) != null;
     }
 
-    public GrailsClass newArtefactClass(Class artefactClass) {
+    @Override
+    public GrailsClass newArtefactClass(@SuppressWarnings("unchecked") Class artefactClass) {
         GrailsDomainClass grailsClass = (GrailsDomainClass) super.newArtefactClass(artefactClass);
-        if(isJPADomainClass(artefactClass))
-            grailsClass.setMappingStrategy(JPA_MAPPING_STRATEGY);        
+        if (isJPADomainClass(artefactClass)) {
+            grailsClass.setMappingStrategy(JPA_MAPPING_STRATEGY);
+        }
         return grailsClass;
     }
 }

src/java/org/codehaus/groovy/grails/commons/AnnotationDomainClassArtefactHandler.java

@@ -3,15 +3,11 @@
 import org.springframework.context.ApplicationContext;
 
 /**
- * Class description here.
- *
  * @author Graeme Rocher
  * @since 0.4
- *        <p/>
- *        Created: Jan 19, 2007
- *        Time: 6:03:55 PM
  */
 public interface ApplicationAttributes {
+
     String APPLICATION_CONTEXT = "org.codehaus.groovy.grails.APPLICATION_CONTEXT";
     String PARENT_APPLICATION_CONTEXT = "org.codehaus.groovy.grails.PARENT_APPLICATION_CONTEXT";
     String REQUEST_SCOPE_ID = "org.codehaus.groovy.grails.GRAILS_APPLICATION_ATTRIBUTES";
@@ -23,7 +19,6 @@ public interface ApplicationAttributes {
     ApplicationContext getApplicationContext();
 
     /**
-     *
      * @return Retrieves the grails application instance
      */
     GrailsApplication getGrailsApplication();

src/java/org/codehaus/groovy/grails/commons/ApplicationAttributes.java

@@ -1,25 +1,27 @@
 /*
-* Copyright 2004-2005 the original author or authors.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
+ * Copyright 2004-2005 the original author or authors.
+ *
+ * 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.
-*/
+ *
+ *      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.codehaus.groovy.grails.commons;
 
 /**
- * <p>Static singleton holder for the GrailsApplication instance</p>
+ * Static singleton holder for the GrailsApplication instance.
+ *
  * @author Marc Palmer ([email protected])
  */
 public abstract class ApplicationHolder {
+
     private static GrailsApplication application;
 
     public static GrailsApplication getApplication() {

src/java/org/codehaus/groovy/grails/commons/ApplicationHolder.java

@@ -19,7 +19,7 @@
  * <p>The ArtefactHandler interface's purpose is to allow the analysis of conventions within a Grails application.
  * An artefact is represented by the GrailsClass interface and this interface provides methods that allow artefacts to
  * be identified, created and initialized.
- *  
+ *
  * <p>Artefacts need to provide info about themselves, and some callbacks are required
  * to verify whether or not a class is that kind of artefact/p>
  *
@@ -31,33 +31,33 @@
 public interface ArtefactHandler {
 
     /**
-     * Obtains the plugin name that deals with this artefact
+     * Obtains the plugin name that deals with this artefact.
      * @return The plugin name or null if there isn't one
      */
     String getPluginName();
 
     /**
-     * <p>Implementations must return a name such as "Domain" to indicate the type of artefact they represent</p>
+     * Implementations must return a name such as "Domain" to indicate the type of artefact they represent.
      * @return The aretfact type, as a String
      */
     String getType();
 
     /**
-     * <p>This method will be called by the GrailsApplication whenever it needs to know if a given class
+     * <p>Called by the GrailsApplication whenever it needs to know if a given class
      * is considered to be the kind of artefact represented by this handler.</p>
-     * <p>Typically you will check the name of the class and some other properties to see if it is of the correct
-     * artefact type</p>
+     * <p>Typically you will check the name of the class and some other properties to see
+     * if it is of the correct artefact type</p>
      * @param aClass A class to test
      * @return True if the class looks like one of your artefacts
      */
-    boolean isArtefact(Class aClass);
+    boolean isArtefact(@SuppressWarnings("unchecked") Class aClass);
 
     /**
      * <p>Called by GrailsApplication when a new class is found and a GrailsClass wrapping it is required</p>
      * @param artefactClass The new class that has been loaded
      * @return A new custom GrailsClass wrapper containing any extra information your artefact type requires
      */
-    GrailsClass newArtefactClass(Class artefactClass);
+    GrailsClass newArtefactClass(@SuppressWarnings("unchecked") Class artefactClass);
 
     /**
      * <p>Called whenever the list of artefacts has changed or been reloaded.</p>

src/java/org/codehaus/groovy/grails/commons/ArtefactHandler.java

@@ -1,50 +1,51 @@
 /*
-* Copyright 2004-2005 the original author or authors.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
+ * Copyright 2004-2005 the original author or authors.
+ *
+ * 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.
-*/
+ *
+ *      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.codehaus.groovy.grails.commons;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 import groovy.lang.Closure;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Modifier;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
 /**
  * @author Marc Palmer ([email protected])
  */
 public class ArtefactHandlerAdapter implements ArtefactHandler {
+
     private String type;
-    private Class grailsClassType;
-    private Class grailsClassImpl;
+    private Class<?> grailsClassType;
+    private Class<?> grailsClassImpl;
     private boolean allowAbstract;
 
     protected Log log = LogFactory.getLog(ArtefactHandlerAdapter.class);
     private String artefactSuffix;
 
-
-    public ArtefactHandlerAdapter(String type, Class grailsClassType, Class grailsClassImpl, String artefactSuffix) {
+    public ArtefactHandlerAdapter(String type, Class<?> grailsClassType, Class<?> grailsClassImpl, String artefactSuffix) {
         this.artefactSuffix = artefactSuffix;
         this.type = type;
         this.grailsClassType = grailsClassType;
         this.grailsClassImpl = grailsClassImpl;
     }
 
-    public ArtefactHandlerAdapter(String type, Class grailsClassType, Class grailsClassImpl, String artefactSuffix,
-        boolean allowAbstract) {
+    public ArtefactHandlerAdapter(String type, Class<?> grailsClassType, Class<?> grailsClassImpl,
+            String artefactSuffix, boolean allowAbstract) {
         this.artefactSuffix = artefactSuffix;
         this.type = type;
         this.grailsClassType = grailsClassType;
@@ -60,29 +61,29 @@ public String getType() {
         return type;
     }
 
-    public final boolean isArtefact(Class aClass) {
+    public final boolean isArtefact(@SuppressWarnings("unchecked") Class aClass) {
         if (isArtefactClass(aClass)) {
             if (log.isDebugEnabled()) {
                 log.debug("[" + aClass.getName() + "] is a " + type + " class.");
             }
             return true;
         }
-        else {
-            if (log.isDebugEnabled()) {
-                log.debug("[" + aClass.getName() + "] is not a " + type + " class.");
-            }
-            return false;
+
+        if (log.isDebugEnabled()) {
+            log.debug("[" + aClass.getName() + "] is not a " + type + " class.");
         }
+        return false;
     }
 
     /**
      * <p>Checks that class's name ends in the suffix specified for this handler.</p>
-     * <p>Override for more complex criteria</p> 
+     * <p>Override for more complex criteria</p>
      * @param clazz The class to check
      * @return True if it is an artefact of this type
      */
-    public boolean isArtefactClass(Class clazz) {
+    public boolean isArtefactClass(@SuppressWarnings("unchecked") Class clazz) {
         if(clazz == null) return false;
+
         boolean ok = clazz.getName().endsWith(artefactSuffix) && !Closure.class.isAssignableFrom(clazz);
         if (ok && !allowAbstract) {
             ok &= !Modifier.isAbstract(clazz.getModifiers());
@@ -96,10 +97,9 @@ public boolean isArtefactClass(Class clazz) {
      * @param artefactClass Creates a new artefact for the given class
      * @return An instance of the GrailsClass interface representing the artefact
      */
-    public GrailsClass newArtefactClass(Class artefactClass) {
-
+    public GrailsClass newArtefactClass(@SuppressWarnings("unchecked") Class artefactClass) {
         try {
-            Constructor c = grailsClassImpl.getDeclaredConstructor(new Class[] { Class.class } );
+            Constructor<?> c = grailsClassImpl.getDeclaredConstructor(new Class[] { Class.class } );
             // TODO GRAILS-720 plugin class instance created here first
             return (GrailsClass) c.newInstance(new Object[] { artefactClass});
         }
@@ -119,9 +119,10 @@ public GrailsClass newArtefactClass(Class artefactClass) {
 
     /**
      * Sets up the relationships between the domain classes, this has to be done after
-     * the intial creation to avoid looping
+     * the intial creation to avoid looping.
      */
     public void initialize(ArtefactInfo artefacts) {
+        // do nothing
     }
 
     public GrailsClass getArtefactForFeature(Object feature) {