Moving 1.x tags

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@835157 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 403 insertions, 0 deletions

diff --git a/sca-java-1.x/tags/0.91-incubating/modules/binding-ejb/src/main/java/org/apache/tuscany/sca/binding/ejb/java2idl/Java2IDLUtil.java b/sca-java-1.x/tags/0.91-incubating/modules/binding-ejb/src/main/java/org/apache/tuscany/sca/binding/ejb/java2idl/Java2IDLUtil.java
new file mode 100644
index 0000000000..b50ec4a04b
--- /dev/null
+++ b/sca-java-1.x/tags/0.91-incubating/modules/binding-ejb/src/main/java/org/apache/tuscany/sca/binding/ejb/java2idl/Java2IDLUtil.java
@@ -0,0 +1,403 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.tuscany.sca.binding.ejb.java2idl;
+
+import java.io.Serializable;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.rmi.Remote;
+import java.rmi.RemoteException;
+
+/**
+ * Java to IDL Language Mapping Specificiation v1.3 (formal/03-09-04) IDL
+ * Utilities
+ */
+public class Java2IDLUtil {
+
+    /*
+     * checks if the method includes java.rmi.RemoteException or its subclass in
+     * its throws clause.
+     */
+    private static boolean throwsRemoteException(Method method) {
+        Class[] exTypes = method.getExceptionTypes();
+        for (int i = 0; i < exTypes.length; ++i) {
+            if (RemoteException.class.isAssignableFrom(exTypes[i]))
+                return true;
+        }
+        return false;
+    }
+
+    /*
+     * checks if the given class is declared as static (inner classes only)
+     */
+    private static boolean isStatic(Class c) {
+        return (Modifier.isStatic(c.getModifiers()));
+    }
+
+    /**
+     * 1.2.1 Overview of Conforming RMI/IDL Types A conforming RMI/IDL type is a
+     * Java type whose values may be transmitted across an RMI/IDL remote
+     * interface at run-time. A Java data type is a conforming RMI/IDL type if
+     * it is: one of the Java primitive types (see Section 1.2.2, "Primitive
+     * Types," on page 1-2). a conforming remote interface (as defined in
+     * Section 1.2.3, "RMI/IDL Remote Interfaces," on page 1-3). a conforming
+     * value type (as defined in Section 1.2.4, "RMI/IDL Value Types," on page
+     * 1-4). an array of conforming RMI/IDL types (see Section 1.2.5, "RMI/IDL
+     * Arrays," on page 1-5). a conforming exception type (see Section 1.2.6,
+     * "RMI/IDL Exception Types," on page 1-5). a conforming CORBA object
+     * reference type (see Section 1.2.7, "CORBA Object Reference Types," on
+     * page 1-6). a conforming IDL entity type (see Section 1.2.8, "IDL Entity
+     * Types," on page 1-6).
+     * 
+     * @param type
+     * @return
+     */
+    public static boolean isIDLType(Class type) {
+        /*
+         * Primitive types. Spec 28.2.2
+         */
+        if (isPrimitiveType(type))
+            return true;
+
+        /*
+         * Conforming array. Spec 28.2.5
+         */
+        if (isIDLArray(type))
+            return true;
+
+        /*
+         * Conforming CORBA reference type. Spec 28.2.7
+         */
+        if (isCORBAObjectType(type))
+            return true;
+
+        /*
+         * Conforming IDL Entity type. Spec 28.2.8
+         */
+        if (isEntityType(type))
+            return true;
+
+        /*
+         * Conforming remote interface. Spec 28.2.3
+         */
+        if (isRemoteInterface(type))
+            return true;
+
+        /*
+         * Conforming exception. Spec 28.2.6
+         */
+        if (isExceptionType(type))
+            return true;
+
+        /*
+         * Conforming value type. Spec 28.2.4
+         */
+        if (isValueType(type))
+            return true;
+
+        return false;
+    }
+
+    /**
+     * Section 1.2.3 RMI/IDL Remote Interfaces
+     * 
+     * @param type
+     * @return
+     */
+    public static boolean isRemoteInterface(Class type) {
+
+        /*
+         * The interface is or inherits from java.rmi.Remote either directly or
+         * indirectly.
+         */
+        if (!Remote.class.isAssignableFrom(type))
+            return false;
+
+        /*
+         * All methods in the interface are defined to throw
+         * java.rmi.RemoteException or a superclass of java.rmi.RemoteException.
+         * Throughout this section, references to methods in the interface
+         * include methods in any inherited interfaces
+         */
+        Method[] methods = type.getMethods();
+        for (int i = 0; i < methods.length; i++) {
+            if (!throwsRemoteException(methods[i])) {
+                return false;
+            }
+
+            /*
+             * All checked exception classes used in method declarations (other
+             * than java.rmi.RemoteException and its subclasses) are conforming
+             * RMI/IDL exception types (see Section 1.2.6, "RMI/IDL Exception
+             * Types," on page 1-5).1
+             */
+            Class[] exTypes = methods[i].getExceptionTypes();
+            for (int j = 0; j < exTypes.length; j++) {
+                if (!isExceptionType(exTypes[j]))
+                    return false;
+            }
+        }
+
+        // TODO: Check method overloading from inherited interfaces
+        /*
+         * Method names may be overloaded. However, when an interface directly
+         * inherits from several base interfaces, it is forbidden for there to
+         * be method name conflicts between the inherited interfaces. This
+         * outlaws the case where an interface A defines a method "foo," an
+         * interface B also defines a method "foo," and an interface C tries to
+         * inherit from both A and B.
+         */
+
+        /*
+         * Constant definitions in the form of interface variables are
+         * permitted. The constant value must be a compile-time constant of one
+         * of the RMI/IDL primitive types or String.
+         */
+        Field[] fields = type.getFields();
+        for (int k = 0; k < fields.length; k++) {
+            Class fieldType = fields[k].getType();
+            if (fieldType.isPrimitive() || fieldType == String.class)
+                continue;
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Section 1.3.11
+     * 
+     * @param type The java class
+     * @return true if it is an IDL abstract interface
+     */
+    public static boolean isAbstractInterface(Class type) {
+        /*
+         * It must be a Java interface.
+         */
+        if (!type.isInterface())
+            return false;
+
+        /*
+         * It must not be the interface of a CORBA object.
+         */
+        if (org.omg.CORBA.Object.class.isAssignableFrom(type))
+            return false;
+
+        /*
+         * It must not extend java.rmi.Remote directly or indirectly.
+         */
+        if (Remote.class.isAssignableFrom(type))
+            return false;
+
+        Method[] methods = type.getMethods();
+
+        for (int i = 0; i < methods.length; i++) {
+            /*
+             * All methods MUST throw java.rmi.RemoteException or a subclass.
+             */
+            if (!throwsRemoteException(methods[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 1.2.6 RMI/IDL Exception Types An RMI/IDL exception type is a checked
+     * exception class (as defined by the Java Language Specification). Since
+     * checked exception classes extend java.lang.Throwable, which implements
+     * java.io.Serializable, it is unnecessary for an RMI/IDL exception class to
+     * directly implement java.io.Serializable.
+     */
+    public static boolean isExceptionType(Class type) {
+
+        /*
+         * Is a checked exception
+         */
+        if (!Throwable.class.isAssignableFrom(type))
+            return false;
+
+        if (Error.class.isAssignableFrom(type))
+            return false;
+
+        if (RuntimeException.class.isAssignableFrom(type))
+            return false;
+
+        /*
+         * meets the requirements for RMI/IDL value types defined in Section
+         * 1.2.4, "RMI/IDL Value Types," on page 1-4.
+         */
+        if (!isValueType(type))
+            return false;
+
+        return true;
+    }
+
+    /**
+     * 1.2.4 RMI/IDL Value Types An RMI/IDL value type represents a class whose
+     * values can be moved between systems. So rather than transmitting a
+     * reference between systems, the actual state of the object is transmitted
+     * between systems. This requires that the receiving system have an
+     * analogous class that can be used to hold the received value. Value types
+     * may be passed as arguments or results of remote methods, or as fields
+     * within other objects that are passed remotely.
+     */
+    public static boolean isValueType(Class type) {
+        /*
+         * The class must implement the java.io.Serializable interface, either
+         * directly or indirectly, and must be serializable at run-time. It may
+         * serialize references to other RMI/IDL types, including value types
+         * and remote interfaces.
+         */
+        if (!Serializable.class.isAssignableFrom(type))
+            return false;
+
+        /*
+         * A value type must not either directly or indirectly implement the
+         * java.rmi.Remote interface. (If this were allowed, then there would be
+         * potential confusion between value types and remote interface
+         * references.)
+         */
+        if (Remote.class.isAssignableFrom(type))
+            return false;
+
+        /*
+         * It cannot be a CORBA object.
+         */
+        if (org.omg.CORBA.Object.class.isAssignableFrom(type))
+            return false;
+
+        /*
+         * If the class is a non-static inner class, then its containing class
+         * must also be a conforming RMI/IDL value type.
+         */
+        if ((type.getDeclaringClass() != null) && (!isStatic(type)))
+            if (!isValueType(type.getDeclaringClass()))
+                return false;
+
+        return true;
+    }
+
+    public static boolean isAbstractValueType(Class type) {
+        if (!type.isInterface())
+            return false;
+
+        if (org.omg.CORBA.Object.class.isAssignableFrom(type))
+            return false;
+
+        boolean cannotBeRemote = false;
+        boolean cannotBeAbstractInterface = false;
+
+        if (java.rmi.Remote.class.isAssignableFrom(type)) {
+            cannotBeAbstractInterface = true;
+        } else {
+            cannotBeRemote = true;
+        }
+
+        Method[] methods = type.getMethods();
+        for (int i = 0; i < methods.length; i++) {
+            if (!throwsRemoteException(methods[i])) {
+                cannotBeAbstractInterface = true;
+                cannotBeRemote = true;
+                break;
+            }
+
+            Class[] exTypes = methods[i].getExceptionTypes();
+            for (int j = 0; j < exTypes.length; j++) {
+                if (!isExceptionType(exTypes[j])) {
+                    cannotBeRemote = true;
+                    break;
+                }
+            }
+        }
+
+        if (!cannotBeRemote) {
+            Field[] fields = type.getFields();
+            for (int k = 0; k < fields.length; k++) {
+                if (fields[k].getType().isPrimitive())
+                    continue;
+                if (fields[k].getType().equals(java.lang.String.class))
+                    continue;
+                cannotBeRemote = true;
+                break;
+            }
+        }
+        return cannotBeRemote && cannotBeAbstractInterface;
+    }
+
+    /**
+     * 1.2.2 Primitive Types All the standard Java primitive types are supported
+     * as part of RMI/IDL. These are: void, boolean, byte, char, short, int,
+     * long, float, double
+     * 
+     * @param type
+     * @return
+     */
+    public static boolean isPrimitiveType(Class type) {
+        return (type != null && type.isPrimitive());
+    }
+
+    /**
+     * 1.2.7 CORBA Object Reference Types A conforming CORBA object reference
+     * type is either
+     * <ul>
+     * <li>the Java interface org.omg.CORBA.Object, or
+     * <li>a Java interface that extends org.omg.CORBA.Object directly or
+     * indirectly and conforms to the rules specified in the Java Language
+     * Mapping (i.e., could have been generated by applying the mapping to an
+     * OMG IDL definition).
+     * </ul>
+     */
+    public static boolean isCORBAObjectType(Class type) {
+        if (type == org.omg.CORBA.Object.class)
+            return true;
+        if (type.isInterface() && org.omg.CORBA.Object.class.isAssignableFrom(type))
+            return true;
+        return false;
+    }
+
+    /**
+     * 1.2.8 IDL Entity Types A Java class is a conforming IDL entity type if it
+     * extends org.omg.CORBA.portable.IDLEntity and conforms to the rules
+     * specified in the Java Language Mapping (i.e., could have been generated
+     * by applying the mapping to an OMG IDL definition) and is not an OMG IDL
+     * user exception.
+     */
+    public static boolean isEntityType(Class type) {
+        if (!org.omg.CORBA.portable.IDLEntity.class.isAssignableFrom(type))
+            return false;
+        if (isExceptionType(type))
+            return false;
+        return true;
+    }
+
+    /**
+     * 1.2.5 RMI/IDL Arrays Arrays of any conforming RMI/IDL type are also
+     * conforming RMI/IDL types. So int[] and String[][][] are conforming
+     * RMI/IDL types. Similarly if Wombat is a conforming RMI/IDL interface
+     * type, then Wombat[] is a conforming RMI/IDL type.
+     */
+    public static boolean isIDLArray(Class type) {
+        if (!type.isArray())
+            return false;
+        Class componentType = type.getComponentType();
+        return isIDLType(componentType);
+    }
+
+}