Attachment #129270 for bug #268592

Lines 9-28 Link Here

(-)src/org/eclipse/persistence/sdo/helper/DynamicClassWriter.java (-10 / +140 lines)
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* Oracle - initial API and implementation from Oracle TopLink	11	* Oracle - initial API and implementation from Oracle TopLink
		12	* bdoughan - Mar 18/2009 - 2.0 - Dynamically generated impl classes now
		13	* implement correct interface.
12	******************************************************************************/	14	******************************************************************************/
13	package org.eclipse.persistence.sdo.helper;	15	package org.eclipse.persistence.sdo.helper;
14		16
15	import java.io.ObjectStreamException;	17	import java.io.ObjectStreamException;
16	import java.io.Serializable;	18	import java.io.Serializable;
		19	import java.lang.reflect.Field;
17	import java.lang.reflect.Method;	20	import java.lang.reflect.Method;
		21	import java.util.List;
18		22
19	import org.eclipse.persistence.sdo.SDOConstants;	23	import org.eclipse.persistence.sdo.SDOConstants;
20	import org.eclipse.persistence.sdo.SDODataObject;	24	import org.eclipse.persistence.sdo.SDODataObject;
		25	import org.eclipse.persistence.sdo.SDOProperty;
21	import org.eclipse.persistence.sdo.SDOType;	26	import org.eclipse.persistence.sdo.SDOType;
		27	import org.eclipse.persistence.sdo.helper.extension.SDOUtil;
22	import org.eclipse.persistence.internal.libraries.asm.ClassWriter;	28	import org.eclipse.persistence.internal.libraries.asm.ClassWriter;
23	import org.eclipse.persistence.internal.libraries.asm.CodeVisitor;	29	import org.eclipse.persistence.internal.libraries.asm.CodeVisitor;
24	import org.eclipse.persistence.internal.libraries.asm.Constants;	30	import org.eclipse.persistence.internal.libraries.asm.Constants;
25	import org.eclipse.persistence.internal.libraries.asm.Type;	31	import org.eclipse.persistence.internal.libraries.asm.Type;
		32	import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
		33
26	import commonj.sdo.helper.HelperContext;	34	import commonj.sdo.helper.HelperContext;
27		35
28	/**	36	/**
Lines 31-49 Link Here
31	* and a writeReplace() method.	39	* and a writeReplace() method.
32	*/	40	*/
33	public class DynamicClassWriter {	41	public class DynamicClassWriter {
		42	static final String START_PROPERTY_INDEX = "START_PROPERTY_INDEX";
		43	static final String END_PROPERTY_INDEX = "END_PROPERTY_INDEX";
		44	static final String GET = "get";
		45	static final String SET = "set";
		46	static final String LIST = "List";
		47	static final String WRITE_REPLACE = "writeReplace";
		48
34	private Class parentClass;	49	private Class parentClass;
35	private String className;	50	private String typeImplClassDescriptor;
36	private SDOType type;	51	private SDOType type;
		52	private Integer startPropertyIndex;
37		53
38	// hold the context containing all helpers so that we can preserve inter-helper relationships	54	// hold the context containing all helpers so that we can preserve inter-helper relationships
39	private HelperContext aHelperContext;	55	private HelperContext aHelperContext;
40		56
41	public DynamicClassWriter(String className, SDOType type, HelperContext aContext) {	57	public DynamicClassWriter(String className, SDOType type, HelperContext aContext) {
42	aHelperContext = aContext;	58	this.aHelperContext = aContext;
43	this.parentClass = SDODataObject.class;	59	this.parentClass = SDODataObject.class;
44	this.className = className;	60	this.typeImplClassDescriptor = className.replace('.', '/');
45	this.type = type;	61	this.type = type;
46	initializeParentClass();	62	initializeParentClass();
		63
		64	if(type.isSubType()) {
		65	try {
		66	Field parentEndPropertyIndexField = PrivilegedAccessHelper.getField(parentClass, END_PROPERTY_INDEX, true);
		67	Integer parentEndPropertyIndex = (Integer) PrivilegedAccessHelper.getValueFromField(parentEndPropertyIndexField, parentClass);
		68	startPropertyIndex = parentEndPropertyIndex + 1;
		69	} catch(NoSuchFieldException e) {
		70	startPropertyIndex = new Integer(0);
		71	} catch(IllegalAccessException e) {
		72	startPropertyIndex = new Integer(0);
		73	}
		74	} else {
		75	startPropertyIndex = new Integer(0);
		76	}
47	}	77	}
48		78
49	private void initializeParentClass() {	79	private void initializeParentClass() {
Lines 67-76 Link Here
67	return this.parentClass;	97	return this.parentClass;
68	}	98	}
69		99
70	public String getClassName() {
71	return this.className;
72	}
73
74	/**	100	/**
75	* This is where the byte codes for the generic subclass are defined and the	101	* This is where the byte codes for the generic subclass are defined and the
76	* class is created dynamically from them.	102	* class is created dynamically from them.
Lines 78-84 Link Here
78	public byte[] createClass() {	104	public byte[] createClass() {
79	ClassWriter cw = new ClassWriter(false);	105	ClassWriter cw = new ClassWriter(false);
80		106
81	cw.visit(Constants.V1_5, Constants.ACC_PUBLIC + Constants.ACC_SUPER, className.replace('.', '/'), Type.getType(parentClass).getInternalName(), null, null);	107	if(null == type.getInstanceClass()) {
		108	cw.visit(Constants.V1_5, Constants.ACC_PUBLIC + Constants.ACC_SUPER, typeImplClassDescriptor, Type.getType(parentClass).getInternalName(), null, null);
		109	} else {
		110	String[] interfaces = new String[1];
		111	interfaces[0] = type.getInstanceClassName().replace('.', '/');
		112	cw.visit(Constants.V1_5, Constants.ACC_PUBLIC + Constants.ACC_SUPER, typeImplClassDescriptor, Type.getType(parentClass).getInternalName(), interfaces, null);
		113	addPropertyIndices(cw);
		114	for(Object object: type.getDeclaredProperties()) {
		115	SDOProperty sdoProperty = (SDOProperty) object;
		116	addPropertyGetMethod(cw, sdoProperty);
		117	addPropertySetMethod(cw, sdoProperty);
		118	}
		119	}
82		120
83	addConstructors(cw);	121	addConstructors(cw);
84	addWriteReplace(cw);	122	addWriteReplace(cw);
Lines 87-93 Link Here
87	return cw.toByteArray();	125	return cw.toByteArray();
88	}	126	}
89		127
90	private void addConstructors(ClassWriter cw) {	128	private void addPropertyIndices(ClassWriter cw) {
		129	cw.visitField(Constants.ACC_PUBLIC + Constants.ACC_FINAL + Constants.ACC_STATIC, START_PROPERTY_INDEX, "I", startPropertyIndex, null);
		130	int declaredPropsSize = type.getDeclaredProperties().size();
		131
		132	Integer endPropertyIndex;
		133	if(declaredPropsSize > 0) {
		134	endPropertyIndex = startPropertyIndex + declaredPropsSize - 2;
		135	} else {
		136	endPropertyIndex = startPropertyIndex - 1;
		137	}
		138	cw.visitField(Constants.ACC_PUBLIC + Constants.ACC_FINAL + Constants.ACC_STATIC, END_PROPERTY_INDEX, "I", endPropertyIndex, null);
		139	}
		140
		141	private void addConstructors(ClassWriter cw) {
91	CodeVisitor mv = cw.visitMethod(Constants.ACC_PUBLIC, "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[0]), new String[] { Type.getInternalName(Serializable.class) }, null);	142	CodeVisitor mv = cw.visitMethod(Constants.ACC_PUBLIC, "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[0]), new String[] { Type.getInternalName(Serializable.class) }, null);
92	mv.visitVarInsn(Constants.ALOAD, 0);	143	mv.visitVarInsn(Constants.ALOAD, 0);
93	mv.visitMethodInsn(Constants.INVOKESPECIAL, Type.getType(parentClass).getInternalName(), "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[0]));	144	mv.visitMethodInsn(Constants.INVOKESPECIAL, Type.getType(parentClass).getInternalName(), "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[0]));
Lines 95-104 Link Here
95	mv.visitMaxs(1, 1);	146	mv.visitMaxs(1, 1);
96	}	147	}
97		148
		149	private void addPropertyGetMethod(ClassWriter cw, SDOProperty property) {
		150	String returnType = SDOUtil.getJavaTypeForProperty(property);
		151	String outerGetMethodName = SDOUtil.getMethodName(property.getName(), returnType);
		152
		153	CodeVisitor mv;
		154	String propertyInstanceClassDescriptor;
		155	if(property.isMany()) {
		156	propertyInstanceClassDescriptor = Type.getDescriptor(List.class);
		157	} else if(property.getType().isDataType()) {
		158	propertyInstanceClassDescriptor = Type.getDescriptor(property.getType().getInstanceClass());
		159	} else {
		160	propertyInstanceClassDescriptor = "L" + returnType.replace('.', '/') + ";";
		161	}
		162	mv = cw.visitMethod(Constants.ACC_PUBLIC, outerGetMethodName, "()" + propertyInstanceClassDescriptor, null, null);
		163
		164	mv.visitVarInsn(Constants.ALOAD, 0);
		165	mv.visitIntInsn(Constants.BIPUSH, startPropertyIndex + property.getIndexInType());
		166
		167	String builtIn = SDOUtil.getBuiltInType(returnType);
		168	if(null != builtIn) {
		169	if(property.getType().isDataType() && !builtIn.equals(LIST)) {
		170	mv.visitMethodInsn(Constants.INVOKEVIRTUAL, typeImplClassDescriptor, GET + builtIn, "(I)" + propertyInstanceClassDescriptor);
		171	int iReturnOpcode = Type.getType(property.getType().getInstanceClass()).getOpcode(Constants.IRETURN);
		172	mv.visitInsn(iReturnOpcode);
		173	} else {
		174	mv.visitMethodInsn(Constants.INVOKEVIRTUAL, typeImplClassDescriptor, GET, "(I)Ljava/lang/Object;");
		175	mv.visitInsn(Constants.ARETURN);
		176	}
		177	} else {
		178	mv.visitMethodInsn(Constants.INVOKEVIRTUAL, typeImplClassDescriptor, GET, "(I)Ljava/lang/Object;");
		179	mv.visitInsn(Constants.ARETURN);
		180	}
		181	mv.visitMaxs(2, 1);
		182	}
		183
		184	private void addPropertySetMethod(ClassWriter cw, SDOProperty property) {
		185	String returnType = SDOUtil.getJavaTypeForProperty(property);
		186	String outerSetMethodName = SDOUtil.setMethodName(property.getName());
		187
		188	CodeVisitor mv;
		189	String propertyInstanceClassDescriptor;
		190
		191	if(property.isMany()) {
		192	propertyInstanceClassDescriptor = Type.getDescriptor(List.class);
		193	} else if(property.getType().isDataType()) {
		194	propertyInstanceClassDescriptor = Type.getDescriptor(property.getType().getInstanceClass());
		195	} else {
		196	propertyInstanceClassDescriptor = "L" + returnType.replace('.', '/') + ";";
		197	}
		198	mv = cw.visitMethod(Constants.ACC_PUBLIC, outerSetMethodName, "(" + propertyInstanceClassDescriptor + ")V", null, null);
		199
		200	mv.visitVarInsn(Constants.ALOAD, 0);
		201	mv.visitIntInsn(Constants.BIPUSH, startPropertyIndex + property.getIndexInType());
		202
		203	String builtIn = SDOUtil.getBuiltInType(returnType);
		204	int iLoadOpcode = Constants.ALOAD;
		205	if(null != builtIn) {
		206	if(property.getType().isDataType() && !builtIn.equals(LIST)) {
		207	iLoadOpcode = Type.getType(property.getType().getInstanceClass()).getOpcode(Constants.ILOAD);
		208	mv.visitVarInsn(iLoadOpcode, 1);
		209	mv.visitMethodInsn(Constants.INVOKEVIRTUAL, typeImplClassDescriptor, SET + builtIn, "(I" + propertyInstanceClassDescriptor + ")V");
		210	} else {
		211	mv.visitVarInsn(iLoadOpcode, 1);
		212	mv.visitMethodInsn(Constants.INVOKEVIRTUAL, typeImplClassDescriptor, SET, "(ILjava/lang/Object;)V");
213	}
214	} else {
215	mv.visitVarInsn(iLoadOpcode, 1);
216	mv.visitMethodInsn(Constants.INVOKEVIRTUAL, typeImplClassDescriptor, SET, "(ILjava/lang/Object;)V");
217	}
218
219	mv.visitInsn(Constants.RETURN);
220	if(iLoadOpcode == Constants.DLOAD \|\| iLoadOpcode == Constants.LLOAD) {
221	mv.visitMaxs(4, 3);
222	} else {
223	mv.visitMaxs(3, 2);
224	}
225	}
226
98	private void addWriteReplace(ClassWriter cw) {	227	private void addWriteReplace(ClassWriter cw) {
99	Method method;	228	Method method;
100	try {	229	try {
101	method = parentClass.getDeclaredMethod("writeReplace", new Class[0]);	230	method = parentClass.getDeclaredMethod(WRITE_REPLACE, new Class[0]);
102	} catch (NoSuchMethodException e) {	231	} catch (NoSuchMethodException e) {
103	return;	232	return;
104	}	233	}
Lines 110-113 Link Here
110	mv.visitInsn(Constants.ARETURN);	239	mv.visitInsn(Constants.ARETURN);
111	mv.visitMaxs(1, 1);	240	mv.visitMaxs(1, 1);
112	}	241	}
		242
113	}	243	}




import java.util.StringTokenizer;

import org.eclipse.persistence.sdo.SDOConstants;
import org.eclipse.persistence.sdo.SDOProperty;
import org.eclipse.persistence.sdo.SDOType;
import org.eclipse.persistence.internal.helper.ClassConstants;
import org.eclipse.persistence.logging.AbstractSessionLog;



    /**
     * INTERNAL:
     * Return a valid Java get method name for a given string
     * @param s
     * @return
     */
    public static String getMethodName(String s) {
        StringBuffer stringbuffer = new StringBuffer();
        // only log the setMethodName call so we do not get double logs
        stringbuffer.append(GET).append(className(s, true, false, false));
        return stringbuffer.toString();
    }

    /**
     * INTERNAL:
     * Return a valid Java get method name for a given string. This method will check
     * the returnType to see if it is a boolean/Boolean:  if so, 'is' will be used in
     * the method name instead of 'get'.

     * @return
     */
    public static String getMethodName(String s, String returnType) {
        try {
            StringBuffer stringBuffer = new StringBuffer();
            if (returnType.equals(ClassConstants.PBOOLEAN.getName()) || returnType.equals(ClassConstants.BOOLEAN.getName())) {
                stringBuffer.append(IS);
            } else {
                stringBuffer.append(GET);
            }
            stringBuffer.append(SDOUtil.className(s, true, false, false));
            return stringBuffer.toString();
        } catch(NullPointerException e) {
            throw e;
        }
        return getMethodName(s);
    }

    /**


        stringbuffer.replace(j, 6, s);
        return stringbuffer.toString();
    }

    public static String getJavaTypeForProperty(SDOProperty property) {
        if (property.isMany() || ((SDOType)property.getType()).isXsdList()) {
            return "java.util.List";
        } else {
            SDOType propertyType = property.getType();
            Class instanceClass = propertyType.getInstanceClass();
            if (ClassConstants.ABYTE.equals(instanceClass)) {
                return "Byte[]";
            } else if (ClassConstants.APBYTE.equals(instanceClass)) {
                return "byte[]";
            }
            return propertyType.getInstanceClassName();
        }
    }

    public static String getBuiltInType(String typeName) {
        if ((typeName.equals(ClassConstants.PBOOLEAN.getName())) || (typeName.equals(ClassConstants.BOOLEAN.getName()))) {
            return "Boolean";
        } else if ((typeName.equals(ClassConstants.PBYTE.getName())) || (typeName.equals(ClassConstants.BYTE.getName()))) {
            return "Byte";
        } else if (typeName.equals("byte[]") || typeName.equals("Byte[]") ||  (typeName.equals(ClassConstants.APBYTE.getName())) || (typeName.equals(ClassConstants.ABYTE.getName()))) {
            return "Bytes";
        } else if ((typeName.equals(ClassConstants.PCHAR.getName())) || (typeName.equals(ClassConstants.CHAR.getName()))) {
            return "Char";
        } else if ((typeName.equals(ClassConstants.PDOUBLE.getName())) || (typeName.equals(ClassConstants.DOUBLE.getName()))) {
            return "Double";
        } else if ((typeName.equals(ClassConstants.PFLOAT.getName())) || (typeName.equals(ClassConstants.FLOAT.getName()))) {
            return "Float";
        } else if ((typeName.equals(ClassConstants.PLONG.getName())) || (typeName.equals(ClassConstants.LONG.getName()))) {
            return "Long";
        } else if ((typeName.equals(ClassConstants.PSHORT.getName())) || (typeName.equals(ClassConstants.SHORT.getName()))) {
            return "Short";
        } else if ((typeName.equals(ClassConstants.PINT.getName())) || (typeName.equals(ClassConstants.INTEGER.getName()))) {
            return "Int";
        } else if (typeName.equals(ClassConstants.STRING.getName())) {
            return "String";
        } else if (typeName.equals(ClassConstants.BIGINTEGER.getName())) {
            return "BigInteger";
        } else if (typeName.equals(ClassConstants.BIGDECIMAL.getName())) {
            return "BigDecimal";
        } else if (typeName.equals(ClassConstants.UTILDATE.getName())) {
            return "Date";
        } else if (typeName.equals("java.util.List")) {
            return "List";
        }
        return null;
    }

}




 ******************************************************************************/  
package org.eclipse.persistence.sdo.helper;

import commonj.sdo.Property;
import commonj.sdo.helper.HelperContext;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

    private static final String lsep2 = lsep + lsep;
    private static final String START_PROPERTY_INDEX = "START_PROPERTY_INDEX";
    private Map generatedBuffers;
    private boolean interfaceGenerator = true;
    private boolean implGenerator = true;
    private CodeWriter codeWriter;
    private SDOClassGeneratorListener sdoClassGeneratorListener;


        generatedBuffers = new HashMap();
    }

    public void setInterfaceGenerator(boolean genIterfaces) {
        interfaceGenerator = genIterfaces;
    }

    public void setImplGenerator(boolean genImpls) {
        implGenerator = genImpls;
    }

    public static void main(String[] args) {
        // default to dynamic context
        SDOClassGenerator generator = new SDOClassGenerator(new SDOHelperContext());

            if (args[i].equals("-help")) {
                generator.printUsage(null);
                System.exit(0);
            } else if (args[i].equals("-sourceFile")) {
            if (args[i].equals("-sourceFile")) {
                if (i == (argsLength - 1)) {
                    generator.printUsage("sdo_classgenerator_usage_missing_sourcefile_value");
                    System.exit(0);
                }
                sourceFile = args[++i];
            } else if (args[i].equals("-targetDirectory")) {
            if (args[i].equals("-targetDirectory")) {
                if (i == (argsLength - 1)) {
                    generator.printUsage("sdo_classgenerator_usage_missing_targetdir");
                    System.exit(0);
                }
                sourceDir = args[++i];
            } else if (args[i].equals("-logLevel")) {
                // log level is optional and will default to INFO
            // log level is optional and will default to INFO
            if (args[i].equals("-logLevel")) {
                if (i != (argsLength - 1)) {
                    AbstractSessionLog.getLog().setLevel(Integer.parseInt(args[++i]));
                }
            } else if (args[i].equals("-noInterfaces")) {
                generator.setInterfaceGenerator(false);
            } else if (args[i].equals("-noImpls")) {
                generator.setImplGenerator(false);
            }
        }
        if (null == sourceFile) {

        
        // Because we can no longer use Helper.cr() inside of message bundles, we must break
        // up the message into separate lines and use Helper.cr() here instead. (bug6470503)
        String messageString = ToStringLocalization.buildMessage("sdo_classgenerator_usage_help_1of8", new Object[] { Helper.getShortClassName(getClass()) });
        messageString += Helper.cr() + Helper.cr();
        messageString += ToStringLocalization.buildMessage("sdo_classgenerator_usage_help_2of8");
        messageString += Helper.cr();
        messageString += ToStringLocalization.buildMessage("sdo_classgenerator_usage_help_3of8");
        messageString += Helper.cr();
        messageString += ToStringLocalization.buildMessage("sdo_classgenerator_usage_help_4of8");
        messageString += Helper.cr();
        messageString += ToStringLocalization.buildMessage("sdo_classgenerator_usage_help_5of8");
        messageString += Helper.cr();
        messageString += ToStringLocalization.buildMessage("sdo_classgenerator_usage_help_6of8");
        messageString += Helper.cr();
        messageString += ToStringLocalization.buildMessage("sdo_classgenerator_usage_help_7of8");
        messageString += Helper.cr();
        messageString += ToStringLocalization.buildMessage("sdo_classgenerator_usage_help_8of8");
        messageString += Helper.cr();

        System.out.println(messageString);
    }



    public Map generate(CodeWriter aCodeWriter, java.util.List types) {
        generatedBuffers = new HashMap();
        generateInterfaces = true;
        codeWriter = aCodeWriter;

        for (int i = 0; i < types.size(); i++) {

                String packageDir = nextBuffer.getPackageName();
                packageDir = packageDir.replace('.', '/');

                if(interfaceGenerator) {
                    getCodeWriter().writeInterface(packageDir, nextBuffer.getInterfaceName() + ".java", nextBuffer.getInterfaceBuffer());
                }
                if(implGenerator) {
                    getCodeWriter().writeImpl(packageDir, nextBuffer.getClassName() + ".java", nextBuffer.getClassBuffer());
                }
            }
        }
        return generatedBuffers;

    private ClassBuffer buildClassForType(SDOType sdoType) {
        ClassBuffer classBuffer = new ClassBuffer(sdoClassGeneratorListener);
        classBuffer.setSdoType(sdoType);
        classBuffer.setGenerateInterface(interfaceGenerator);
        classBuffer.setSdoTypeName(sdoType.getName());
        StringBuffer currentClassBuffer = new StringBuffer();
        if (sdoClassGeneratorListener != null) {

        }

        currentClassBuffer.append("extends ").append(implExtends);
        if (interfaceGenerator) {
            currentClassBuffer.append(" implements ")//
            .append(interfaceName);
        }

        classBuffer.getMethodBuffer().append(buildNoArgCtor(fullClassName));
        currentClassBuffer.append(indent).append(" {").append(lsep2);

        if (interfaceGenerator) {
            StringBuffer currentInterfaceBuffer = new StringBuffer();
            if (sdoClassGeneratorListener != null) {
                sdoClassGeneratorListener.preInterfacePackage(currentInterfaceBuffer);

     * @param className
     */
    private void buildGetMethodBuffer(ClassBuffer classBuffer, SDOProperty property, java.util.List documentation) {
        String returnType = SDOUtil.getJavaTypeForProperty(property);
        String methodName = SDOUtil.getMethodName(property.getName(), returnType);

        if (!(property.getType().isChangeSummaryType() && methodName.equals("getChangeSummary"))) {

            pushIndent();
            classBuffer.getMethodBuffer().append(indent).append("return ");
            //cast return value        
            String builtIn = SDOUtil.getBuiltInType(returnType);

            if (builtIn != null) {
                String wrapperCall = getWrapperCall(returnType);

            popIndent();
            classBuffer.getMethodBuffer().append(indent).append("}").append(lsep2);
        }
        if (interfaceGenerator) {
            classBuffer.getInterfaceBuffer().append(indent);
            classBuffer.getInterfaceBuffer().append("public ");
            classBuffer.getInterfaceBuffer().append(returnType).append(" ");

        classBuffer.getMethodBuffer().append(methodName);
        classBuffer.getMethodBuffer().append("(");

        String paramType = SDOUtil.getJavaTypeForProperty(property);

        classBuffer.getMethodBuffer().append(paramType).append(" value");


        classBuffer.getMethodBuffer().append(indent).append("}");
        classBuffer.getMethodBuffer().append(lsep2);

        if (interfaceGenerator) {
            classBuffer.getInterfaceBuffer().append(indent);
            classBuffer.getInterfaceBuffer().append("public void ");
            classBuffer.getInterfaceBuffer().append(methodName);

        indent = buf.toString();
    }

    /**
     * INTERNAL:
     * @param qualifiedName
     * @param targetNamespace
     * @return
     */
    private String getBuiltInType(String typeName) {
        if ((typeName.equals(ClassConstants.PBOOLEAN.getName())) || (typeName.equals(ClassConstants.BOOLEAN.getName()))) {
            return "Boolean";
        } else if ((typeName.equals(ClassConstants.PBYTE.getName())) || (typeName.equals(ClassConstants.BYTE.getName()))) {
            return "Byte";
        } else if ((typeName.equals(ClassConstants.APBYTE.getName())) || (typeName.equals(ClassConstants.ABYTE.getName()))) {
            return "Bytes";
        } else if ((typeName.equals(ClassConstants.PCHAR.getName())) || (typeName.equals(ClassConstants.CHAR.getName()))) {
            return "Char";
        } else if ((typeName.equals(ClassConstants.PDOUBLE.getName())) || (typeName.equals(ClassConstants.DOUBLE.getName()))) {
            return "Double";
        } else if ((typeName.equals(ClassConstants.PFLOAT.getName())) || (typeName.equals(ClassConstants.FLOAT.getName()))) {
            return "Float";
        } else if ((typeName.equals(ClassConstants.PLONG.getName())) || (typeName.equals(ClassConstants.LONG.getName()))) {
            return "Long";
        } else if ((typeName.equals(ClassConstants.PSHORT.getName())) || (typeName.equals(ClassConstants.SHORT.getName()))) {
            return "Short";
        } else if ((typeName.equals(ClassConstants.PINT.getName())) || (typeName.equals(ClassConstants.INTEGER.getName()))) {
            return "Int";
        } else if (typeName.equals(ClassConstants.STRING.getName())) {
            return "String";
        } else if (typeName.equals(ClassConstants.BIGINTEGER.getName())) {
            return "BigInteger";
        } else if (typeName.equals(ClassConstants.BIGDECIMAL.getName())) {
            return "BigDecimal";
        } else if (typeName.equals(ClassConstants.UTILDATE.getName())) {
            return "Date";
        } else if (typeName.equals("java.util.List")) {
            return "List";
        }

        return null;
    }

    public void setGeneratedBuffers(Map generatedBuffersMap) {
        generatedBuffers = generatedBuffersMap;
    }

        return null;
    }

    private String getJavaTypeForProperty(SDOProperty property) {
        if (property.isMany() || ((SDOType)property.getType()).isXsdList()) {
            return "java.util.List";
        } else {
            SDOType propertyType = property.getType();
            Class instanceClass = propertyType.getInstanceClass();
            if (ClassConstants.ABYTE.equals(instanceClass)) {
                return "Byte[]";
            } else if (ClassConstants.APBYTE.equals(instanceClass)) {
                return "byte[]";
            }
            return propertyType.getInstanceClassName();
        }
    }

    public void setCodeWriter(CodeWriter theCodeWriter) {
        codeWriter = theCodeWriter;
    }

Lines 2432-2437 Link Here

(-)src/org/eclipse/persistence/sdo/helper/SDOTypesGenerator.java (+1 lines)
2432	if(sdoType == null) {	2432	if(sdoType == null) {
2433	sdoType = new SDOType(typeURI, typeName, sdoTypeHelper);	2433	sdoType = new SDOType(typeURI, typeName, sdoTypeHelper);
2434	sdoType.setXsdLocalName(complexType.getName());	2434	sdoType.setXsdLocalName(complexType.getName());
		2435	sdoType.preInitialize(packageName, namespaceResolvers);
2435	}	2436	}
2436	sdoType.setXsd(true);	2437	sdoType.setXsd(true);
2437	if(!sdoType.getQName().equals(sdoType.getXsdType())) {	2438	if(!sdoType.getQName().equals(sdoType.getXsdType())) {




        getXmlDescriptor().setJavaClassName(getImplClassName());
        // load classes by classloader by getting the current instance class
        getInstanceClass();
        getImplClass();

        // See SDOResolvable enhancement
        String schemaContext = getName();

            sdoRefMapping.setField(xmlField);
            xmlDescriptor.addMapping(sdoRefMapping);
        }
        if(!isDataType()) {
            getImplClass();
        }
    }

    /**





    public SDODataType(String aUri, String aName, SDOTypeHelper sdoTypeHelper) {
        super(aUri, aName, sdoTypeHelper);
        isDataType = true;
    }

    public SDODataType(String aUri, String aName, Class aClass, SDOTypeHelper sdoTypeHelper) {
        this(aUri, aName, sdoTypeHelper);
        setInstanceClass(aClass);
        isDataType = true;
        xmlDescriptor = null;
    }


Return to bug 268592

Lines 758-764 Link Here

(-)src/org/eclipse/persistence/sdo/SDOType.java (-1 / +3 lines)
758	getXmlDescriptor().setJavaClassName(getImplClassName());	758	getXmlDescriptor().setJavaClassName(getImplClassName());
759	// load classes by classloader by getting the current instance class	759	// load classes by classloader by getting the current instance class
760	getInstanceClass();	760	getInstanceClass();
761	getImplClass();
762		761
763	// See SDOResolvable enhancement	762	// See SDOResolvable enhancement
764	String schemaContext = getName();	763	String schemaContext = getName();
Lines 807-812 Link Here
807	sdoRefMapping.setField(xmlField);	806	sdoRefMapping.setField(xmlField);
808	xmlDescriptor.addMapping(sdoRefMapping);	807	xmlDescriptor.addMapping(sdoRefMapping);
809	}	808	}
		809	if(!isDataType()) {
		810	getImplClass();
		811	}
810	}	812	}
811		813
812	/**	814	/**

Lines 18-23 Link Here

(-)src/org/eclipse/persistence/sdo/helper/extension/SDOUtil.java (-20 / +63 lines)
18	import java.util.StringTokenizer;	18	import java.util.StringTokenizer;
19		19
20	import org.eclipse.persistence.sdo.SDOConstants;	20	import org.eclipse.persistence.sdo.SDOConstants;
		21	import org.eclipse.persistence.sdo.SDOProperty;
		22	import org.eclipse.persistence.sdo.SDOType;
21	import org.eclipse.persistence.internal.helper.ClassConstants;	23	import org.eclipse.persistence.internal.helper.ClassConstants;
22	import org.eclipse.persistence.logging.AbstractSessionLog;	24	import org.eclipse.persistence.logging.AbstractSessionLog;
23		25
Lines 467-485 Link Here
467		469
468	/**	470	/**
469	* INTERNAL:	471	* INTERNAL:
470	* Return a valid Java get method name for a given string
471	* @param s
472	* @return
473	*/
474	public static String getMethodName(String s) {
475	StringBuffer stringbuffer = new StringBuffer();
476	// only log the setMethodName call so we do not get double logs
477	stringbuffer.append(GET).append(className(s, true, false, false));
478	return stringbuffer.toString();
479	}
480
481	/**
482	* INTERNAL:
483	* Return a valid Java get method name for a given string. This method will check	472	* Return a valid Java get method name for a given string. This method will check
484	* the returnType to see if it is a boolean/Boolean: if so, 'is' will be used in	473	* the returnType to see if it is a boolean/Boolean: if so, 'is' will be used in
485	* the method name instead of 'get'.	474	* the method name instead of 'get'.
Lines 489-501 Link Here
489	* @return	478	* @return
490	*/	479	*/
491	public static String getMethodName(String s, String returnType) {	480	public static String getMethodName(String s, String returnType) {
492	if (returnType.equals(ClassConstants.PBOOLEAN.getName()) \|\| returnType.equals(ClassConstants.BOOLEAN.getName())) {	481	try {
493	StringBuffer stringbuffer = new StringBuffer();	482	StringBuffer stringBuffer = new StringBuffer();
494	// only log the setMethodName call so we do not get double logs	483	if (returnType.equals(ClassConstants.PBOOLEAN.getName()) \|\| returnType.equals(ClassConstants.BOOLEAN.getName())) {
495	stringbuffer.append(IS).append(SDOUtil.className(s, true, false, false));	484	stringBuffer.append(IS);
496	return stringbuffer.toString();	485	} else {
		486	stringBuffer.append(GET);
		487	}
		488	stringBuffer.append(SDOUtil.className(s, true, false, false));
		489	return stringBuffer.toString();
		490	} catch(NullPointerException e) {
		491	throw e;
497	}	492	}
498	return getMethodName(s);
499	}	493	}
500		494
501	/**	495	/**
Lines 651-655 Link Here
651		645
652	stringbuffer.replace(j, 6, s);	646	stringbuffer.replace(j, 6, s);
653	return stringbuffer.toString();	647	return stringbuffer.toString();
654	}	648	}
		649
		650	public static String getJavaTypeForProperty(SDOProperty property) {
		651	if (property.isMany() \|\| ((SDOType)property.getType()).isXsdList()) {
		652	return "java.util.List";
		653	} else {
		654	SDOType propertyType = property.getType();
		655	Class instanceClass = propertyType.getInstanceClass();
		656	if (ClassConstants.ABYTE.equals(instanceClass)) {
		657	return "Byte[]";
		658	} else if (ClassConstants.APBYTE.equals(instanceClass)) {
		659	return "byte[]";
		660	}
		661	return propertyType.getInstanceClassName();
		662	}
		663	}
		664
		665	public static String getBuiltInType(String typeName) {
		666	if ((typeName.equals(ClassConstants.PBOOLEAN.getName())) \|\| (typeName.equals(ClassConstants.BOOLEAN.getName()))) {
		667	return "Boolean";
		668	} else if ((typeName.equals(ClassConstants.PBYTE.getName())) \|\| (typeName.equals(ClassConstants.BYTE.getName()))) {
		669	return "Byte";
		670	} else if (typeName.equals("byte[]") \|\| typeName.equals("Byte[]") \|\| (typeName.equals(ClassConstants.APBYTE.getName())) \|\| (typeName.equals(ClassConstants.ABYTE.getName()))) {
		671	return "Bytes";
		672	} else if ((typeName.equals(ClassConstants.PCHAR.getName())) \|\| (typeName.equals(ClassConstants.CHAR.getName()))) {
		673	return "Char";
		674	} else if ((typeName.equals(ClassConstants.PDOUBLE.getName())) \|\| (typeName.equals(ClassConstants.DOUBLE.getName()))) {
		675	return "Double";
		676	} else if ((typeName.equals(ClassConstants.PFLOAT.getName())) \|\| (typeName.equals(ClassConstants.FLOAT.getName()))) {
		677	return "Float";
		678	} else if ((typeName.equals(ClassConstants.PLONG.getName())) \|\| (typeName.equals(ClassConstants.LONG.getName()))) {
		679	return "Long";
		680	} else if ((typeName.equals(ClassConstants.PSHORT.getName())) \|\| (typeName.equals(ClassConstants.SHORT.getName()))) {
		681	return "Short";
		682	} else if ((typeName.equals(ClassConstants.PINT.getName())) \|\| (typeName.equals(ClassConstants.INTEGER.getName()))) {
		683	return "Int";
		684	} else if (typeName.equals(ClassConstants.STRING.getName())) {
		685	return "String";
		686	} else if (typeName.equals(ClassConstants.BIGINTEGER.getName())) {
		687	return "BigInteger";
		688	} else if (typeName.equals(ClassConstants.BIGDECIMAL.getName())) {
		689	return "BigDecimal";
		690	} else if (typeName.equals(ClassConstants.UTILDATE.getName())) {
		691	return "Date";
		692	} else if (typeName.equals("java.util.List")) {
		693	return "List";
		694	}
		695	return null;
		696	}
		697
655	}	698	}

Lines 23-34 Link Here

(-)src/org/eclipse/persistence/sdo/types/SDODataType.java (-1 / +1 lines)
23		23
24	public SDODataType(String aUri, String aName, SDOTypeHelper sdoTypeHelper) {	24	public SDODataType(String aUri, String aName, SDOTypeHelper sdoTypeHelper) {
25	super(aUri, aName, sdoTypeHelper);	25	super(aUri, aName, sdoTypeHelper);
		26	isDataType = true;
26	}	27	}
27		28
28	public SDODataType(String aUri, String aName, Class aClass, SDOTypeHelper sdoTypeHelper) {	29	public SDODataType(String aUri, String aName, Class aClass, SDOTypeHelper sdoTypeHelper) {
29	this(aUri, aName, sdoTypeHelper);	30	this(aUri, aName, sdoTypeHelper);
30	setInstanceClass(aClass);	31	setInstanceClass(aClass);
31	isDataType = true;
32	xmlDescriptor = null;	32	xmlDescriptor = null;
33	}	33	}
34		34