Signature.java

Go to the documentation of this file.

package jvn;

import java.lang.annotation.Annotation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class Signature {

        String annotations;
        String modifiers;
        String name;
        String ucfirstName;
        String parameters;
        //String parameterTypes;
        String parameterNames;
        String exceptions;
        String returnType;
        Integer type;
        
        public Signature() {
        }
        
        public void setValues(AccessibleObject c) {
                
                Type [] parms = null;
                Type [] excepts = null;
                Annotation [] annots = null;
                Annotation [][] parmAnnots = null;
                String [] strings = null;
                
                String dummy = null;
                String dummy2 = null;
                
                
                if (c instanceof Constructor) {
                        type = 1; // Constructor;
                        parms = ((Constructor)c).getGenericParameterTypes();
                        excepts = ((Constructor)c).getGenericExceptionTypes();
                        annots = ((Constructor)c).getAnnotations();
                        parmAnnots = ((Constructor)c).getParameterAnnotations();
                        modifiers = Modifier.toString(((Constructor)c).getModifiers());
                        name = ((Constructor)c).getName();
                        returnType = "";
                }
                else if (c instanceof Method) {
                        Class<?> classReturnType = ((Method)c).getReturnType();
                        
                        type = 2;
                        parms = ((Method)c).getGenericParameterTypes();
                        excepts = ((Method)c).getGenericExceptionTypes();
                        annots = ((Method)c).getAnnotations();
                        parmAnnots = ((Method)c).getParameterAnnotations();
                        modifiers = Modifier.toString(((Method)c).getModifiers());
                        name = ((Method)c).getName();
                        returnType = classReturnType.getName();
                }
                else {
                        System.err.println("Wrong object type passed to Signature.setValues !");
                        System.exit(1);
                }
                
                
                annotations = new String(""); 
                if (annots != null) {
                        for (Annotation a : annots) {
                                String annot = a.toString();
                                annotations = annotations + annot + " ";
                                if (annot.equals("@jvn.JvnRead()")) {
                                        type = 3; // @JvnRead method
                                }
                                else if (annot.equals("@jvn.JvnWrite()")) {
                                        type = 4; // @JvnWrite method
                                }
                        }
                }
                if (annotations.equals("")) {
                        annotations = null;
                }
                
                
                if (modifiers.equals("")) {
                        modifiers = null;
                }
                

                if (returnType.equals("")) {
                        returnType = null;
                }

        
                if (name.equals("")) {
                        System.err.println("Constructor/method name is empty ?!");
                        System.exit(1);
                }
                
                // Class name is the last part of the whole class name. Straightforward.
                strings = name.split("\\.");
                name = strings[strings.length - 1];
                // Put the first letter in uppercase. Not so straightforward...
                dummy = name.substring(1);
                dummy2 = name.substring(0,1).toUpperCase();
                ucfirstName = dummy2.concat(dummy);

                
                // TODO FIXME: handle "public Foo(java.lang.Serializable o)"
                // Don't have an clue on how to solve the problem for now.
                parameters = new String("");
                parameterNames = new String("");
                //parameterTypes = new String("");
                
                if (parms != null) {
                        for (int i = 0; i < parms.length; i++) {
                                Annotation [] aArray = (parmAnnots != null)?parmAnnots[i]:null;
                                
                                // Don't add "," if it's the last parameter.
                                String tempParmName = "param" + i + ((i == parms.length - 1)?"":", ");
                                String tempParmType = parms[i].toString();
                                String tempParmAnnot = new String("");
                                
                                if (aArray != null) {
                                        for (Annotation a : aArray) {
                                                tempParmAnnot = tempParmAnnot.concat(a.toString()).concat(" ");
                                        }
                                }
        
                                // Strip the "class " in front of tempParmType;
                                tempParmType = stripTrailingClass(tempParmType);
        
                                parameters = parameters.concat(tempParmAnnot).concat(tempParmType).concat(" ").concat(tempParmName);
                                parameterNames = parameterNames.concat(tempParmName);
                        }
                }
                
                
                exceptions = new String("");
                if (excepts != null) {
                        for (Type e : excepts) {
                                String s = e.toString();
                                s = stripTrailingClass(s);
                                
                                exceptions = exceptions + s + ", ";
                        }
                }
                // Add JvnException to list of exceptions.
                exceptions = exceptions + "jvn.JvnException";
                // Shouldn't happen...
                /*if (exceptions.equals("")) {
                        exceptions = null;
                }*/
                
        }

        // Method extracted by ultra-powerful Eclipse -> Refactor -> Extract Method !
        // It even found and correctly replaced a similar block of code.
        private String stripTrailingClass(String s) {
                String result = s;
                Pattern p = Pattern.compile("^(class\\s)(([A-Za-z][A-Za-z0-9.]*)+)$");
                Matcher matcher = p.matcher(s);
                if (matcher.matches()) {
                        result = matcher.group(2);
                }
                else {
                        // Do nothing.
                }
                return result;
        }

        public String getAnnotations() {
                //System.out.println("OUAH" + annotations);
                return annotations;
        }

        public String getExceptions() {
                return exceptions;
        }

        public String getModifiers() {
                return modifiers;
        }

        public String getName() {
                return name;
        }

        public String getParameters() {
                return parameters;
        }
        
        public int getType() {
                return type;
        }

        public String getParameterNames() {
                return parameterNames;
        }

        /*public String getParameterTypes() {
                return parameterTypes;
        }*/

        public String getReturnType() {
                return returnType;
        }

        public String getUcfirstName() {
                return ucfirstName;
        }

}

---