| /* |
| * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code 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 General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| /* |
| * Licensed Materials - Property of IBM |
| * RMI-IIOP v1.0 |
| * Copyright IBM Corp. 1998 1999 All Rights Reserved |
| * |
| */ |
| |
| package com.sun.corba.se.impl.io; |
| |
| import com.sun.org.omg.CORBA.ValueDefPackage.FullValueDescription; |
| import com.sun.org.omg.CORBA.OperationDescription; |
| import com.sun.org.omg.CORBA.AttributeDescription; |
| import org.omg.CORBA.ValueMember; |
| import com.sun.org.omg.CORBA.Initializer; |
| import org.omg.CORBA.IDLType; |
| import com.sun.org.omg.CORBA._IDLTypeStub; |
| import org.omg.CORBA.ORB; |
| import org.omg.CORBA.TypeCodePackage.*; |
| import org.omg.CORBA.TypeCode; |
| import org.omg.CORBA.TCKind; |
| import java.lang.reflect.*; |
| import com.sun.corba.se.impl.util.RepositoryId; |
| import java.util.*; |
| import javax.rmi.CORBA.Util; |
| import javax.rmi.CORBA.ValueHandler; |
| |
| /** |
| * Holds utility methods for converting from ObjectStreamClass to |
| * FullValueDescription and generating typecodes from ObjectStreamClass. |
| **/ |
| public class ValueUtility { |
| |
| public static final short PRIVATE_MEMBER = 0; |
| public static final short PUBLIC_MEMBER = 1; |
| |
| private static final String primitiveConstants[] = { |
| null, // tk_null 0 |
| null, // tk_void 1 |
| "S", // tk_short 2 |
| "I", // tk_long 3 |
| "S", // tk_ushort 4 |
| "I", // tk_ulong 5 |
| "F", // tk_float 6 |
| "D", // tk_double 7 |
| "Z", // tk_boolean 8 |
| "C", // tk_char 9 |
| "B", // tk_octet 10 |
| null, // tk_any 11 |
| null, // tk_typecode 12 |
| null, // tk_principal 13 |
| null, // tk_objref 14 |
| null, // tk_struct 15 |
| null, // tk_union 16 |
| null, // tk_enum 17 |
| null, // tk_string 18 |
| null, // tk_sequence 19 |
| null, // tk_array 20 |
| null, // tk_alias 21 |
| null, // tk_except 22 |
| "J", // tk_longlong 23 |
| "J", // tk_ulonglong 24 |
| "D", // tk_longdouble 25 |
| "C", // tk_wchar 26 |
| null, // tk_wstring 27 |
| null, // tk_fixed 28 |
| null, // tk_value 29 |
| null, // tk_value_box 30 |
| null, // tk_native 31 |
| null, // tk_abstract_interface 32 |
| }; |
| |
| static { |
| sun.corba.SharedSecrets.setJavaCorbaAccess(new sun.corba.JavaCorbaAccess() { |
| public ValueHandlerImpl newValueHandlerImpl() { |
| return ValueHandlerImpl.getInstance(); |
| } |
| public Class<?> loadClass(String className) throws ClassNotFoundException { |
| if (Thread.currentThread().getContextClassLoader() != null) { |
| return Thread.currentThread().getContextClassLoader(). |
| loadClass(className); |
| } else { |
| return ClassLoader.getSystemClassLoader().loadClass(className); |
| } |
| } |
| }); |
| } |
| |
| public static String getSignature(ValueMember member) |
| throws ClassNotFoundException { |
| |
| // REVISIT. Can the type be something that is |
| // non-primitive yet not a value_box, value, or objref? |
| // If so, should use ObjectStreamClass or throw |
| // exception. |
| |
| if (member.type.kind().value() == TCKind._tk_value_box || |
| member.type.kind().value() == TCKind._tk_value || |
| member.type.kind().value() == TCKind._tk_objref) { |
| Class c = RepositoryId.cache.getId(member.id).getClassFromType(); |
| return ObjectStreamClass.getSignature(c); |
| |
| } else { |
| |
| return primitiveConstants[member.type.kind().value()]; |
| } |
| |
| } |
| |
| public static FullValueDescription translate(ORB orb, ObjectStreamClass osc, ValueHandler vh){ |
| |
| // Create FullValueDescription |
| FullValueDescription result = new FullValueDescription(); |
| Class className = osc.forClass(); |
| |
| ValueHandlerImpl vhandler = (com.sun.corba.se.impl.io.ValueHandlerImpl) vh; |
| String repId = vhandler.createForAnyType(className); |
| |
| // Set FVD name |
| result.name = vhandler.getUnqualifiedName(repId); |
| if (result.name == null) |
| result.name = ""; |
| |
| // Set FVD id _REVISIT_ : Manglings |
| result.id = vhandler.getRMIRepositoryID(className); |
| if (result.id == null) |
| result.id = ""; |
| |
| // Set FVD is_abstract |
| result.is_abstract = ObjectStreamClassCorbaExt.isAbstractInterface(className); |
| |
| // Set FVD is_custom |
| result.is_custom = osc.hasWriteObject() || osc.isExternalizable(); |
| |
| // Set FVD defined_in _REVISIT_ : Manglings |
| result.defined_in = vhandler.getDefinedInId(repId); |
| if (result.defined_in == null) |
| result.defined_in = ""; |
| |
| // Set FVD version |
| result.version = vhandler.getSerialVersionUID(repId); |
| if (result.version == null) |
| result.version = ""; |
| |
| // Skip FVD operations - N/A |
| result.operations = new OperationDescription[0]; |
| |
| // Skip FVD attributed - N/A |
| result.attributes = new AttributeDescription[0]; |
| |
| // Set FVD members |
| // Maps classes to repositoryIDs strings. This is used to detect recursive types. |
| IdentityKeyValueStack createdIDs = new IdentityKeyValueStack(); |
| // Stores all types created for resolving indirect types at the end. |
| result.members = translateMembers(orb, osc, vh, createdIDs); |
| |
| // Skip FVD initializers - N/A |
| result.initializers = new Initializer[0]; |
| |
| Class interfaces[] = osc.forClass().getInterfaces(); |
| int abstractCount = 0; |
| |
| // Skip FVD supported_interfaces |
| result.supported_interfaces = new String[interfaces.length]; |
| for (int interfaceIndex = 0; interfaceIndex < interfaces.length; |
| interfaceIndex++) { |
| result.supported_interfaces[interfaceIndex] = |
| vhandler.createForAnyType(interfaces[interfaceIndex]); |
| |
| if ((!(java.rmi.Remote.class.isAssignableFrom(interfaces[interfaceIndex]))) || |
| (!Modifier.isPublic(interfaces[interfaceIndex].getModifiers()))) |
| abstractCount++; |
| } |
| |
| // Skip FVD abstract_base_values - N/A |
| result.abstract_base_values = new String[abstractCount]; |
| for (int interfaceIndex = 0; interfaceIndex < interfaces.length; |
| interfaceIndex++) { |
| if ((!(java.rmi.Remote.class.isAssignableFrom(interfaces[interfaceIndex]))) || |
| (!Modifier.isPublic(interfaces[interfaceIndex].getModifiers()))) |
| result.abstract_base_values[interfaceIndex] = |
| vhandler.createForAnyType(interfaces[interfaceIndex]); |
| |
| } |
| |
| result.is_truncatable = false; |
| |
| // Set FVD base_value |
| Class superClass = osc.forClass().getSuperclass(); |
| if (java.io.Serializable.class.isAssignableFrom(superClass)) |
| result.base_value = vhandler.getRMIRepositoryID(superClass); |
| else |
| result.base_value = ""; |
| |
| // Set FVD type |
| //result.type = createTypeCodeForClass(orb, osc.forClass()); |
| result.type = orb.get_primitive_tc(TCKind.tk_value); //11638 |
| |
| return result; |
| |
| } |
| |
| private static ValueMember[] translateMembers (ORB orb, |
| ObjectStreamClass osc, |
| ValueHandler vh, |
| IdentityKeyValueStack createdIDs) |
| { |
| ValueHandlerImpl vhandler = (com.sun.corba.se.impl.io.ValueHandlerImpl) vh; |
| ObjectStreamField fields[] = osc.getFields(); |
| int fieldsLength = fields.length; |
| ValueMember[] members = new ValueMember[fieldsLength]; |
| // Note : fields come out of ObjectStreamClass in correct order for |
| // writing. So, we will create the same order in the members array. |
| for (int i = 0; i < fieldsLength; i++) { |
| String valRepId = vhandler.getRMIRepositoryID(fields[i].getClazz()); |
| members[i] = new ValueMember(); |
| members[i].name = fields[i].getName(); |
| members[i].id = valRepId; // _REVISIT_ : Manglings |
| members[i].defined_in = vhandler.getDefinedInId(valRepId);// _REVISIT_ : Manglings |
| members[i].version = "1.0"; |
| members[i].type_def = new _IDLTypeStub(); // _REVISIT_ : IDLType implementation missing |
| |
| if (fields[i].getField() == null) { |
| // When using serialPersistentFields, the class may |
| // no longer have an actual Field that corresponds |
| // to one of the items. The Java to IDL spec |
| // ptc-00-01-06 1.3.5.6 says that the IDL field |
| // should be private in this case. |
| members[i].access = PRIVATE_MEMBER; |
| } else { |
| int m = fields[i].getField().getModifiers(); |
| if (Modifier.isPublic(m)) |
| members[i].access = PUBLIC_MEMBER; |
| else |
| members[i].access = PRIVATE_MEMBER; |
| } |
| |
| switch (fields[i].getTypeCode()) { |
| case 'B': |
| members[i].type = orb.get_primitive_tc(TCKind.tk_octet); //11638 |
| break; |
| case 'C': |
| members[i].type |
| = orb.get_primitive_tc(vhandler.getJavaCharTCKind()); // 11638 |
| break; |
| case 'F': |
| members[i].type = orb.get_primitive_tc(TCKind.tk_float); //11638 |
| break; |
| case 'D' : |
| members[i].type = orb.get_primitive_tc(TCKind.tk_double); //11638 |
| break; |
| case 'I': |
| members[i].type = orb.get_primitive_tc(TCKind.tk_long); //11638 |
| break; |
| case 'J': |
| members[i].type = orb.get_primitive_tc(TCKind.tk_longlong); //11638 |
| break; |
| case 'S': |
| members[i].type = orb.get_primitive_tc(TCKind.tk_short); //11638 |
| break; |
| case 'Z': |
| members[i].type = orb.get_primitive_tc(TCKind.tk_boolean); //11638 |
| break; |
| // case '[': |
| // members[i].type = orb.get_primitive_tc(TCKind.tk_value_box); //11638 |
| // members[i].id = RepositoryId.createForAnyType(fields[i].getType()); |
| // break; |
| default: |
| members[i].type = createTypeCodeForClassInternal(orb, fields[i].getClazz(), vhandler, |
| createdIDs); |
| members[i].id = vhandler.createForAnyType(fields[i].getType()); |
| break; |
| } // end switch |
| |
| } // end for loop |
| |
| return members; |
| } |
| |
| private static boolean exists(String str, String strs[]){ |
| for (int i = 0; i < strs.length; i++) |
| if (str.equals(strs[i])) |
| return true; |
| |
| return false; |
| } |
| |
| public static boolean isAssignableFrom(String clzRepositoryId, FullValueDescription type, |
| com.sun.org.omg.SendingContext.CodeBase sender){ |
| |
| if (exists(clzRepositoryId, type.supported_interfaces)) |
| return true; |
| |
| if (clzRepositoryId.equals(type.id)) |
| return true; |
| |
| if ((type.base_value != null) && |
| (!type.base_value.equals(""))) { |
| FullValueDescription parent = sender.meta(type.base_value); |
| |
| return isAssignableFrom(clzRepositoryId, parent, sender); |
| } |
| |
| return false; |
| |
| } |
| |
| public static TypeCode createTypeCodeForClass (ORB orb, java.lang.Class c, ValueHandler vh) { |
| // Maps classes to repositoryIDs strings. This is used to detect recursive types. |
| IdentityKeyValueStack createdIDs = new IdentityKeyValueStack(); |
| // Stores all types created for resolving indirect types at the end. |
| TypeCode tc = createTypeCodeForClassInternal(orb, c, vh, createdIDs); |
| return tc; |
| } |
| |
| private static TypeCode createTypeCodeForClassInternal (ORB orb, |
| java.lang.Class c, |
| ValueHandler vh, |
| IdentityKeyValueStack createdIDs) |
| { |
| // This wrapper method is the protection against infinite recursion. |
| TypeCode tc = null; |
| String id = (String)createdIDs.get(c); |
| if (id != null) { |
| return orb.create_recursive_tc(id); |
| } else { |
| id = vh.getRMIRepositoryID(c); |
| if (id == null) id = ""; |
| // cache the rep id BEFORE creating a new typecode. |
| // so that recursive tc can look up the rep id. |
| createdIDs.push(c, id); |
| tc = createTypeCodeInternal(orb, c, vh, id, createdIDs); |
| createdIDs.pop(); |
| return tc; |
| } |
| } |
| |
| // Maintains a stack of key-value pairs. Compares elements using == operator. |
| private static class IdentityKeyValueStack { |
| private static class KeyValuePair { |
| Object key; |
| Object value; |
| KeyValuePair(Object key, Object value) { |
| this.key = key; |
| this.value = value; |
| } |
| boolean equals(KeyValuePair pair) { |
| return pair.key == this.key; |
| } |
| } |
| |
| Stack pairs = null; |
| |
| Object get(Object key) { |
| if (pairs == null) { |
| return null; |
| } |
| for (Iterator i = pairs.iterator(); i.hasNext();) { |
| KeyValuePair pair = (KeyValuePair)i.next(); |
| if (pair.key == key) { |
| return pair.value; |
| } |
| } |
| return null; |
| } |
| |
| void push(Object key, Object value) { |
| if (pairs == null) { |
| pairs = new Stack(); |
| } |
| pairs.push(new KeyValuePair(key, value)); |
| } |
| |
| void pop() { |
| pairs.pop(); |
| } |
| } |
| |
| private static TypeCode createTypeCodeInternal (ORB orb, |
| java.lang.Class c, |
| ValueHandler vh, |
| String id, |
| IdentityKeyValueStack createdIDs) |
| { |
| if ( c.isArray() ) { |
| // Arrays - may recurse for multi-dimensional arrays |
| Class componentClass = c.getComponentType(); |
| TypeCode embeddedType; |
| if ( componentClass.isPrimitive() ){ |
| embeddedType |
| = ValueUtility.getPrimitiveTypeCodeForClass(orb, |
| componentClass, |
| vh); |
| } else { |
| embeddedType = createTypeCodeForClassInternal(orb, componentClass, vh, |
| createdIDs); |
| } |
| TypeCode t = orb.create_sequence_tc (0, embeddedType); |
| return orb.create_value_box_tc (id, "Sequence", t); |
| } else if ( c == java.lang.String.class ) { |
| // Strings |
| TypeCode t = orb.create_string_tc (0); |
| return orb.create_value_box_tc (id, "StringValue", t); |
| } else if (java.rmi.Remote.class.isAssignableFrom(c)) { |
| return orb.get_primitive_tc(TCKind.tk_objref); |
| } else if (org.omg.CORBA.Object.class.isAssignableFrom(c)) { |
| return orb.get_primitive_tc(TCKind.tk_objref); |
| } |
| |
| // Anything else |
| |
| ObjectStreamClass osc = ObjectStreamClass.lookup(c); |
| |
| if (osc == null) { |
| return orb.create_value_box_tc (id, "Value", orb.get_primitive_tc (TCKind.tk_value)); |
| } |
| |
| // type modifier |
| // REVISIT truncatable and abstract? |
| short modifier = (osc.isCustomMarshaled() ? org.omg.CORBA.VM_CUSTOM.value : org.omg.CORBA.VM_NONE.value); |
| |
| // concrete base |
| TypeCode base = null; |
| Class superClass = c.getSuperclass(); |
| if (superClass != null && java.io.Serializable.class.isAssignableFrom(superClass)) { |
| base = createTypeCodeForClassInternal(orb, superClass, vh, createdIDs); |
| } |
| |
| // members |
| ValueMember[] members = translateMembers (orb, osc, vh, createdIDs); |
| |
| return orb.create_value_tc(id, c.getName(), modifier, base, members); |
| } |
| |
| public static TypeCode getPrimitiveTypeCodeForClass (ORB orb, |
| Class c, |
| ValueHandler vh) { |
| |
| if (c == Integer.TYPE) { |
| return orb.get_primitive_tc (TCKind.tk_long); |
| } else if (c == Byte.TYPE) { |
| return orb.get_primitive_tc (TCKind.tk_octet); |
| } else if (c == Long.TYPE) { |
| return orb.get_primitive_tc (TCKind.tk_longlong); |
| } else if (c == Float.TYPE) { |
| return orb.get_primitive_tc (TCKind.tk_float); |
| } else if (c == Double.TYPE) { |
| return orb.get_primitive_tc (TCKind.tk_double); |
| } else if (c == Short.TYPE) { |
| return orb.get_primitive_tc (TCKind.tk_short); |
| } else if (c == Character.TYPE) { |
| return orb.get_primitive_tc (((ValueHandlerImpl)vh).getJavaCharTCKind()); |
| } else if (c == Boolean.TYPE) { |
| return orb.get_primitive_tc (TCKind.tk_boolean); |
| } else { |
| // _REVISIT_ Not sure if this is right. |
| return orb.get_primitive_tc (TCKind.tk_any); |
| } |
| } |
| } |
