org/objectweb/proactive/core/mop/Utils.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.core.mop;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;


public abstract class Utils extends Object {

    public static final Class<?> JAVA_LANG_NUMBER = silentForName(
            "java.lang.Number");
    public static final Class<?> JAVA_LANG_CHARACTER = silentForName(
            "java.lang.Character");
    public static final Class<?> JAVA_LANG_BOOLEAN = silentForName(
            "java.lang.Boolean");
    public static final Class<?> JAVA_LANG_VOID = silentForName(
            "java.lang.Void");
    public static final Class<?> JAVA_LANG_RUNTIMEEXCEPTION = silentForName(
            "java.lang.RuntimeException");
    public static final Class<?> JAVA_LANG_EXCEPTION = silentForName(
            "java.lang.Exception");
    public static final Class<?> JAVA_LANG_THROWABLE = silentForName(
            "java.lang.Throwable");

    public static final char STUB_ESCAPE_CHAR = '_';
    public static final String STUB_ESCAPE = "" + STUB_ESCAPE_CHAR +
        STUB_ESCAPE_CHAR;

    public static final char STUB_PACKAGE_SEPARATOR_CHAR = 'P';
    public static final String STUB_PACKAGE_SEPARATOR = "" + STUB_ESCAPE_CHAR +
        STUB_PACKAGE_SEPARATOR_CHAR;

    public static final char STUB_GENERICS_SEPARATOR_CHAR = 'D';
    public static final String STUB_GENERICS_SEPARATOR = "" + STUB_ESCAPE_CHAR +
        STUB_GENERICS_SEPARATOR_CHAR;

    //prefix and suffix
    public static final String STUB_DEFAULT_PREFIX = STUB_ESCAPE_CHAR + "Stub";

    // stub on generic types are generated with a suffix that indicates the parameterizing types
    public static final String STUB_GENERICS_SUFFIX = STUB_ESCAPE_CHAR +
        "Generics";

    //  packages
    public static final String STUB_DEFAULT_PACKAGE = "pa.stub.";

    //  stub on generic types are generated in a different package
    public static final String STUB_GENERICS_PACKAGE = "parameterized.";

    static public String getRidOfNative(String in) {
        String result;
        int leftindex;
        int rightindex;

        leftindex = in.indexOf("native");
        if (leftindex == -1) {
            return in;
        }
        rightindex = leftindex + 6;

        result = in.substring(0, leftindex) +
            in.substring(rightindex, in.length());
        return result;
    }

    static public String getRidOfAbstract(String in) {
        String result;
        int leftindex;
        int rightindex;

        leftindex = in.indexOf("abstract");
        if (leftindex == -1) {
            return in;
        }
        rightindex = leftindex + 8;

        result = in.substring(0, leftindex) +
            in.substring(rightindex, in.length());
        return result;
    }

    static public String getRidOfNativeAndAbstract(String in) {
        String s = in;
        s = getRidOfAbstract(s);
        return getRidOfNative(s);
    }

    static public boolean checkMethod(Method met) {
        int modifiers = met.getModifiers();

        // Final methods cannot be reified since we cannot redefine them
        // in a subclass
        if (Modifier.isFinal(modifiers)) {
            return false;
        }

        // Static methods cannot be reified since they are not 'virtual'
        if (Modifier.isStatic(modifiers)) {
            return false;
        }
        if (!(Modifier.isPublic(modifiers))) {
            return false;
        }

        // If method is finalize (), don't reify it
        if ((met.getName().equals("finalize")) &&
                (met.getParameterTypes().length == 0)) {
            return false;
        }
        return true;
    }

    static public String sourceLikeForm(Class cl) {
        if (!(cl.isArray())) {
            //to fix an issue with jdk1.3 and inner class
            // A$B should be A.B in source code
            //System.out.println("Remplacing in " + cl.getName());
            return cl.getName().replace('$', '.');
        } else {
            int nb = 0;
            Class current = cl;
            String result = "";

            do {
                current = current.getComponentType();
                result = "[]" + result;
                nb++;
            } while ((current.getComponentType()) != null);

            result = current.getName() + result;
            return result;
        }
    }

    /*
     * Returns the name of the wrapper class for class <code>cl</code>.
     * If <code>cl</code> is not a primitive type, returns <code>null</code>
     */
    static public String nameOfWrapper(Class cl) {
        String str = cl.getName();

        if (cl.isPrimitive()) {
            if (str.equals("int")) {
                return "java.lang.Integer";
            } else if (str.equals("boolean")) {
                return "java.lang.Boolean";
            } else if (str.equals("byte")) {
                return "java.lang.Byte";
            } else if (str.equals("short")) {
                return "java.lang.Short";
            } else if (str.equals("long")) {
                return "java.lang.Long";
            } else if (str.equals("float")) {
                return "java.lang.Float";
            } else if (str.equals("double")) {
                return "java.lang.Double";
            } else if (str.equals("void")) {
                return "void";
            } else if (str.equals("char")) {
                return "java.lang.Character";
            } else {
                throw new InternalException("Unknown primitive type: " +
                    cl.getName());
            }
        } else {
            return null;
        }
    }

    /*
     * Extract the package name from the fully qualified class name given as
     * an argument
     */
    public static String getPackageName(String fqnameofclass) {
        int indexoflastdot;

        indexoflastdot = fqnameofclass.lastIndexOf('.');

        if (indexoflastdot == -1) {
            return "";
        } else {
            return fqnameofclass.substring(0, indexoflastdot);
        }
    }

    public static String getSimpleName(String fullyQualifiedNameOfClass) {
        int indexOfLastDot = fullyQualifiedNameOfClass.lastIndexOf('.');
        if (indexOfLastDot == -1) // There are no dots
         {
            return fullyQualifiedNameOfClass;
        } else {
            // If last character is a dot, returns an empty string
            if (indexOfLastDot == (fullyQualifiedNameOfClass.length() - 1)) {
                return "";
            } else {
                return fullyQualifiedNameOfClass.substring(indexOfLastDot + 1);
            }
        }
    }

    public static Class getWrapperClass(Class cl) {
        if (!(cl.isPrimitive())) {
            return null;
        }
        String s = Utils.nameOfWrapper(cl);
        try {
            return MOP.forName(s);
        } catch (ClassNotFoundException e) {
            throw new InternalException("Cannot load wrapper class " + s);
        }
    }

    public static Class getPrimitiveType(Class cl) {
        Field cst;
        if (Utils.isWrapperClass(cl)) {
            // These types are not classes , yet class static variables
            // We want to locale the TYPE field in the class
            try {
                cst = cl.getField("TYPE");
                return (Class) cst.get(null);
            } catch (NoSuchFieldException e) {
                throw new InternalException(
                    "Cannot locate constant TYPE in class " + cl.getName());
            } catch (SecurityException e) {
                throw new InternalException("Access to field TYPE in class " +
                    cl.getName() + " denied");
            } catch (IllegalAccessException e) {
                throw new InternalException("Access to field TYPE in class " +
                    cl.getName() + " denied");
            }
        } else {
            throw new InternalException("Not a wrapper class: " + cl.getName());
        }
    }

    public static boolean isWrapperClass(Class<?> cl) {
        if (Utils.JAVA_LANG_NUMBER.isAssignableFrom(cl)) {
            return true;
        } else if (Utils.JAVA_LANG_BOOLEAN.isAssignableFrom(cl)) {
            return true;
        } else if (Utils.JAVA_LANG_CHARACTER.isAssignableFrom(cl)) {
            return true;
        } else if (Utils.JAVA_LANG_VOID.isAssignableFrom(cl)) {
            return true;
        } else {
            return false;
        }
    }

    public static String getRelativePath(String className) {
        String packageName;
        String fileSeparator;
        String result;
        int indexOfDot;
        int indexOfLastDot;

        fileSeparator = System.getProperty("file.separator");
        packageName = Utils.getPackageName(className);

        indexOfDot = packageName.indexOf((int) '.', 0);
        result = "";
        indexOfLastDot = 0;

        while (indexOfDot != -1) {
            result = result + fileSeparator +
                packageName.substring(indexOfLastDot, indexOfDot);
            indexOfLastDot = indexOfDot + 1;
            indexOfDot = packageName.indexOf((int) '.', indexOfDot + 1);
            if (indexOfDot == -1) {
                result = result + fileSeparator +
                    packageName.substring(indexOfLastDot, packageName.length());
            }
        }

        if (result.equals("")) {
            result = fileSeparator + packageName;
        }

        return result;
    }

    /*
       public static String getStubName(String nameOfClass) {
         return Utils.getPackageName(nameOfClass) + "." + STUB_DEFAULT_PREFIX + Utils.getSimpleName(nameOfClass);
       }
     */
    public static boolean isNormalException(Class exc) {
        boolean result;

        if (Utils.JAVA_LANG_THROWABLE.isAssignableFrom(exc)) {
            // It is a subclass of Throwable
            if (Utils.JAVA_LANG_EXCEPTION.isAssignableFrom(exc)) {
                if (Utils.JAVA_LANG_RUNTIMEEXCEPTION.isAssignableFrom(exc)) {
                    result = false;
                } else {
                    result = true;
                }
            } else {
                result = false; // This must be an Error
            }
        } else {
            result = false;
        }

        return result;
    }

    public static Class decipherPrimitiveType(String str) {
        if (str.equals("int")) {
            return java.lang.Integer.TYPE;
        } else if (str.equals("boolean")) {
            return java.lang.Boolean.TYPE;
        } else if (str.equals("byte")) {
            return java.lang.Byte.TYPE;
        } else if (str.equals("short")) {
            return java.lang.Short.TYPE;
        } else if (str.equals("long")) {
            return java.lang.Long.TYPE;
        } else if (str.equals("float")) {
            return java.lang.Float.TYPE;
        } else if (str.equals("double")) {
            return java.lang.Double.TYPE;
        } else if (str.equals("void")) {
            return java.lang.Void.TYPE;
        } else if (str.equals("char")) {
            return java.lang.Character.TYPE;
        }

        return null;
    }

    public static boolean isSuperTypeInArray(String className, Class[] types) {
        try {
            Class c = MOP.forName(className);
            return isSuperTypeInArray(c, types);
        } catch (ClassNotFoundException e) {
            throw new InternalException(e);
        }
    }

    public static boolean isSuperTypeInArray(Class c, Class<?>[] types) {
        for (int i = 0; i < types.length; i++) {
            if (types[i].isAssignableFrom(c)) {
                return true;
            }
        }
        return false;
    }

    public static Object makeDeepCopy(Object source) throws java.io.IOException {
        java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();

        //java.io.ObjectOutputStream oos = new java.io.ObjectOutputStream(baos);
        java.io.ObjectOutputStream oos = new PAObjectOutputStream(baos);
        oos.writeObject(source);
        oos.flush();
        oos.close();
        java.io.ByteArrayInputStream bais = new java.io.ByteArrayInputStream(baos.toByteArray());

        //    java.io.ObjectInputStream ois = new java.io.ObjectInputStream(bais);
        java.io.ObjectInputStream ois = new PAObjectInputStream(bais);
        try {
            Object result = ois.readObject();
            ois.close();
            return result;
        } catch (ClassNotFoundException e) {
            throw new java.io.IOException("ClassNotFoundException e=" + e);
        }
    }

    public static String convertClassNameToStubClassName(String classname,
        Class[] genericParameters) {
        if (classname.length() == 0) {
            return classname;
        }
        String packageName = getPackageName(classname);
        if (!packageName.equals("")) {
            packageName += ".";
        }
        packageName = STUB_DEFAULT_PACKAGE +
            (((genericParameters == null) || (genericParameters.length == 0))
            ? "" : STUB_GENERICS_PACKAGE) + packageName;

        String genericsDifferentiator = "";
        if (genericParameters != null) {
            for (Class gClassName : genericParameters) {
                if (!genericsDifferentiator.equals("")) {
                    genericsDifferentiator += STUB_GENERICS_SEPARATOR;
                }
                genericsDifferentiator += escapeClassName(gClassName.getName());
            }
            if (!genericsDifferentiator.equals("")) {
                genericsDifferentiator = STUB_GENERICS_SUFFIX +
                    genericsDifferentiator;
            }
        }

        return packageName + STUB_DEFAULT_PREFIX +
        escapeClassName(getSimpleName(classname)) + genericsDifferentiator;
    }

    public static boolean isStubClassName(String classname) {
        if (classname.startsWith(STUB_DEFAULT_PACKAGE)) {
            // Extracts the simple name from the fully-qualified class name
            int index = classname.lastIndexOf(".");
            if (index != -1) {
                return classname.startsWith(Utils.STUB_DEFAULT_PREFIX, index +
                    1);
            } else {
                return classname.startsWith(Utils.STUB_DEFAULT_PREFIX);
            }
        } else {
            return false;
        }
    }

    public static String convertStubClassNameToClassName(String stubclassname) {
        return unEscapeStubClassesName(stubclassname, false).get(0).toString();
    }

    public static String[] getNamesOfParameterizingTypesFromStubClassName(
        String stubClassName) {
        if (!isStubClassName(stubClassName)) {
            return new String[] {  };
        }
        if (!stubClassName.startsWith(Utils.STUB_DEFAULT_PACKAGE +
                    Utils.STUB_GENERICS_PACKAGE)) {
            // no generics
            return new String[] {  };
        }
        List<CharSequence> classesName = unEscapeStubClassesName(stubClassName,
                true);
        classesName.remove(0);
        String[] result = new String[classesName.size()];
        for (int i = 0; i < result.length; i++) {
            result[i] = classesName.get(i).toString();
        }
        return result;
    }

    private static String escapeClassName(String className) {
        StringBuilder sb = new StringBuilder(className.length() * 2);
        for (int i = 0; i < className.length(); i++) {
            switch (className.charAt(i)) {
            case '.':
                sb.append(STUB_PACKAGE_SEPARATOR);
                break;
            case STUB_ESCAPE_CHAR:
                sb.append(STUB_ESCAPE);
                break;
            default:
                sb.append(className.charAt(i));
                break;
            }
        }
        return sb.toString();
    }

    private static List<CharSequence> unEscapeStubClassesName(
        String stubClassName, boolean withParameterizingTypes)
        throws IllegalArgumentException {
        ArrayList<CharSequence> result = new ArrayList<CharSequence>();
        StringBuilder sb = new StringBuilder(stubClassName.length());
        boolean stubFlag = false;
        boolean genericFlag = false;
        boolean genericPackage = false;

        if (isStubClassName(stubClassName)) {
            String temp = "";
            if (stubClassName.startsWith(Utils.STUB_DEFAULT_PACKAGE +
                        Utils.STUB_GENERICS_PACKAGE)) {
                genericPackage = true;
                // remove generics stuff
                temp = stubClassName.substring((Utils.STUB_DEFAULT_PACKAGE +
                        Utils.STUB_GENERICS_PACKAGE).length());
            } else {
                temp = stubClassName.substring(Utils.STUB_DEFAULT_PACKAGE.length());
            }
            temp = Utils.getPackageName(temp);
            if (temp.length() != 0) {
                sb.append(temp);
                sb.append('.');
            }

            //a Stub classe is necessary under a package i.e. Utils.STUB_DEFAULT_PACKAGE
            int begin = stubClassName.lastIndexOf('.');
            if (begin == -1) {
                begin = 0;
            }
            for (int i = begin + 1; i < stubClassName.length(); i++) {
                char c = stubClassName.charAt(i);
                if (c != STUB_ESCAPE_CHAR) {
                    sb.append(c);
                } else {
                    i++;
                    switch (stubClassName.charAt(i)) {
                    // one char Flags : 'STUB_ESCAPE_CHAR''a_char' 
                    case STUB_PACKAGE_SEPARATOR_CHAR:
                        sb.append('.');
                        break;
                    case STUB_ESCAPE_CHAR:
                        sb.append(STUB_ESCAPE_CHAR);
                        ;
                        break;
                    case STUB_GENERICS_SEPARATOR_CHAR:
                        result.add(sb);
                        sb = new StringBuilder(stubClassName.length());
                        break;

                    // multiple char Flags <=> 'STUB_ESCAPE_CHAR'"a_string"
                    case 'S':
                        if (stubClassName.startsWith(STUB_DEFAULT_PREFIX, i -
                                    1)) { //Stub
                            if (stubFlag) {
                                throw new IllegalArgumentException(
                                    "The escapedClassesName is not a well formed escaped string at index " +
                                    i + ", the flag STUB_DEFAULT_PREFIX (" +
                                    STUB_DEFAULT_PREFIX +
                                    ") are present twice : " + stubClassName);
                            }
                            stubFlag = true;
                            i += (STUB_DEFAULT_PREFIX.length() - 2); // 2 char _S
                        }
                        break;
                    case 'G':
                        if (stubClassName.startsWith(STUB_GENERICS_SUFFIX, i -
                                    1)) { //Generics
                            if (genericFlag || !genericPackage) {
                                throw new IllegalArgumentException(
                                    "The escapedClassesName is not a well formed escaped string at index " +
                                    i + ", the flag STUB_GENERICS_SUFFIX (" +
                                    STUB_GENERICS_SUFFIX +
                                    ") are present twice  or this class is not in the STUB_GENERICS_PACKAGE (" +
                                    STUB_DEFAULT_PACKAGE +
                                    STUB_GENERICS_PACKAGE + "): " +
                                    stubClassName);
                            }
                            genericFlag = true;
                            i += (STUB_GENERICS_SUFFIX.length() - 2); // 2 char _G

                            result.add(sb);
                            if (!withParameterizingTypes) {
                                return result;
                            } else {
                                sb = new StringBuilder(stubClassName.length());
                            }
                        }
                        break;
                    default:
                        //ERROR
                        throw new IllegalArgumentException(
                            "The escapedClassesName is not a well formed escaped string at index " +
                            i + " : " + stubClassName);
                    }
                }
            }
            result.add(sb);
            return result;
        } else {
            result.add(stubClassName);
            return result;
        }
    }

    public static void addSuperInterfaces(Class cl, List<Class> superItfs) {
        if (!cl.isInterface()) {
            return;
        }
        Class[] super_interfaces = cl.getInterfaces();
        for (int i = 0; i < super_interfaces.length; i++) {
            superItfs.add(super_interfaces[i]);
            addSuperInterfaces(super_interfaces[i], superItfs);
        }
    }

    public static void addSuperInterfaces(List<Class> interfaces) {
        for (int i = 0; i < interfaces.size(); i++) {
            Class[] super_itfs_table = interfaces.get(i).getInterfaces();
            List<Class> super_itfs = new ArrayList<Class>(super_itfs_table.length); // resizable list
            for (int j = 0; j < super_itfs_table.length; j++) {
                super_itfs.add(super_itfs_table[j]);
            }
            addSuperInterfaces(super_itfs);
            for (int j = 0; j < super_itfs.size(); j++) {
                if (!interfaces.contains(super_itfs.get(j))) {
                    interfaces.add(super_itfs.get(j));
                }
            }
        }
    }

    private static final Class silentForName(String classname) {
        try {
            return MOP.forName(classname);
        } catch (ClassNotFoundException e) {
            System.err.println(
                "Static initializer in class org.objectweb.proactive.core.mop.Utils: Cannot load class " +
                classname);
            return null;
        }
    }
}

---