valueutility.java

java jdk 1.4的源码

            }

	    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);
	}
    }
}