Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/ImplHelper.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/ImplHelper.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/ImplHelper.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/ImplHelper.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,950 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.jdo.impl.enhancer.generator; + +import java.util.List; +import java.util.ArrayList; +import java.util.HashMap; + + +/** + * + */ +final class ImplHelper + extends NameHelper +{ + // string constants + static final String[] COMMENT_ENHANCER_ADDED + = null; //{ "added by enhancer" }; + static final String[] COMMENT_NOT_ENHANCER_ADDED + = null; //{ "not added by enhancer" }; + + static final String CLASSNAME_JDO_PERSISTENCE_CAPABLE + = "javax.jdo.spi.PersistenceCapable"; + static final String CLASSNAME_JDO_PERSISTENCE_MANAGER + = "javax.jdo.PersistenceManager"; + static final String CLASSNAME_JDO_IMPL_HELPER + = "javax.jdo.spi.JDOImplHelper"; + static final String CLASSNAME_JDO_STATE_MANAGER + = "javax.jdo.spi.StateManager"; + static final String CLASSNAME_JDO_PERMISSION + = "javax.jdo.spi.JDOPermission"; + static final String CLASSNAME_JDO_USER_EXCEPTION + = "javax.jdo.JDOUserException"; + //static final String CLASSNAME_JDO_FATAL_INTERNAL_EXCEPTION + //= "javax.jdo.JDOFatalInternalException"; + static final String CLASSNAME_JDO_OBJECT_ID_FIELD_SUPPLIER + = CLASSNAME_JDO_PERSISTENCE_CAPABLE + "." + "ObjectIdFieldSupplier"; + static final String CLASSNAME_JDO_OBJECT_ID_FIELD_CONSUMER + = CLASSNAME_JDO_PERSISTENCE_CAPABLE + "." + "ObjectIdFieldConsumer"; + + static final String FIELDNAME_JDO_FLAGS + = "jdoFlags"; + static final String FIELDNAME_JDO_STATE_MANAGER + = "jdoStateManager"; + static final String FIELDNAME_JDO_INHERITED_FIELD_COUNT + = "jdoInheritedFieldCount"; + static final String FIELDNAME_JDO_FIELD_NAMES + = "jdoFieldNames"; + static final String FIELDNAME_JDO_FIELD_TYPES + = "jdoFieldTypes"; + static final String FIELDNAME_JDO_FIELD_FLAGS + = "jdoFieldFlags"; + static final String FIELDNAME_JDO_PC_SUPERCLASS + = "jdoPersistenceCapableSuperclass"; + static final String FIELDNAME_SERIAL_VERSION_UID + = "serialVersionUID"; + + static final String METHODNAME_WRITE_OBJECT + = "writeObject"; + + static final String METHODNAME_JDO_GET_MANAGED_FIELD_COUNT + = "jdoGetManagedFieldCount"; + static final String METHODNAME_JDO_NEW_INSTANCE + = "jdoNewInstance"; + static final String METHODNAME_JDO_NEW_OID_INSTANCE + = "jdoNewObjectIdInstance"; + static final String METHODNAME_JDO_REPLACE_STATE_MANAGER + = "jdoReplaceStateManager"; + static final String METHODNAME_JDO_REPLACE_FLAGS + = "jdoReplaceFlags"; + static final String METHODNAME_JDO_REPLACE_FIELD + = "jdoReplaceField"; + static final String METHODNAME_JDO_REPLACE_FIELDS + = "jdoReplaceFields"; + static final String METHODNAME_JDO_PROVIDE_FIELD + = "jdoProvideField"; + static final String METHODNAME_JDO_PROVIDE_FIELDS + = "jdoProvideFields"; + static final String METHODNAME_JDO_COPY_FIELDS + = "jdoCopyFields"; + static final String METHODNAME_JDO_COPY_FIELD + = "jdoCopyField"; + static final String METHODNAME_JDO_PRE_SERIALIZE + = "jdoPreSerialize"; + static final String METHODNAME_JDO_GET_PERSISTENCE_MANAGER + = "jdoGetPersistenceManager"; + static final String METHODNAME_JDO_MAKE_DIRTY + = "jdoMakeDirty"; + static final String METHODNAME_JDO_GET_OBJECT_ID + = "jdoGetObjectId"; + static final String METHODNAME_JDO_GET_TRANSACTIONAL_OBJECT_ID + = "jdoGetTransactionalObjectId"; + static final String METHODNAME_JDO_IS_PERSISTENT + = "jdoIsPersistent"; + static final String METHODNAME_JDO_IS_TRANSACTIONAL + = "jdoIsTransactional"; + static final String METHODNAME_JDO_IS_NEW + = "jdoIsNew"; + static final String METHODNAME_JDO_IS_DIRTY + = "jdoIsDirty"; + static final String METHODNAME_JDO_IS_DELETED + = "jdoIsDeleted"; + static final String METHODNAME_JDO_COPY_KEY_FIELDS_TO_OID + = "jdoCopyKeyFieldsToObjectId"; + static final String METHODNAME_JDO_COPY_KEY_FIELDS_FROM_OID + = "jdoCopyKeyFieldsFromObjectId"; + + static private final HashMap typeNameConversion = new HashMap(); + static + { + typeNameConversion.put(int.class.getName(), "Int"); + typeNameConversion.put(long.class.getName(), "Long"); + typeNameConversion.put(byte.class.getName(), "Byte"); + typeNameConversion.put(char.class.getName(), "Char"); + typeNameConversion.put(boolean.class.getName(), "Boolean"); + typeNameConversion.put(short.class.getName(), "Short"); + typeNameConversion.put(float.class.getName(), "Float"); + typeNameConversion.put(double.class.getName(), "Double"); + typeNameConversion.put("String", "String"); + } + + static private String getConvertedTypeName(String fieldtype) + { + final String name = (String)typeNameConversion.get(fieldtype); + return (name != null ? name : "Object"); + } + + static private String getMethodNameGetField(String fieldtype) + { + return "get" + getConvertedTypeName(fieldtype) + "Field"; + } + + static private String getMethodNameSetField(String fieldtype) + { + return "set" + getConvertedTypeName(fieldtype) + "Field"; + } + + static private String getMethodNameReplacingField(String fieldtype) + { + return "replacing" + getConvertedTypeName(fieldtype) + "Field"; + } + + static private String getMethodNameProvidedField(String fieldtype) + { + return "provided" + getConvertedTypeName(fieldtype) + "Field"; + } + + static private String getMethodNameFetchField(String fieldtype) + { + return "fetch" + getConvertedTypeName(fieldtype) + "Field"; + } + + static private String getMethodNameStoreField(String fieldtype) + { + return "store" + getConvertedTypeName(fieldtype) + "Field"; + } + + // ---------------------------------------------------------------------- + + static String createJDOFieldAccessorName(String classname, + String fieldname) + { + return "jdoGet" + fieldname; + } + + static String createJDOFieldMutatorName(String classname, + String fieldname) + { + return "jdoSet" + fieldname; + } + + // Create initial values of fields. + + static String getJDOInheritedFieldCountInitValue(String superclassname) + { + return(superclassname == null ? + "0" : + (normalizeClassName(superclassname) + + '.' + METHODNAME_JDO_GET_MANAGED_FIELD_COUNT + "()")); + } + + static String getJDOFieldNamesInitValue(String[] fieldnames) + { + String value = "new String[]{ "; + final int n = fieldnames.length; + for (int i = 0; i < n; i++) { + value += "\"" + fieldnames[i] + "\""; + if (i < n - 1) { + value += ", "; + } + } + return value + " }"; + } + + static String getJDOFieldTypesInitValue(String[] fieldtypes) + { + String value = "new Class[]{ "; + final int n = fieldtypes.length; + for (int i = 0; i < n; i++) { + value += normalizeClassName(fieldtypes[i]) + ".class"; + if (i < n - 1) { + value += ", "; + } + } + return value + " }"; + } + + static String getJDOFieldFlagsInitValue(int[] fieldflags) + { + String value = "new byte[]{ "; + final int n = fieldflags.length; + for (int i = 0; i < n; i++) { + value += "0x" + Integer.toHexString(fieldflags[i]); + if (i < n - 1) { + value += ", "; + } + } + return value + " }"; + } + + static String getJDOPCSuperclassInitValue(String superclass) + { + return (superclass == null + ? "null" + : normalizeClassName(superclass) + ".class"); + } + + static String getSerialVersionUIDInitValue(long uid) + { + return uid + "L"; + } + + // Create bodies of methods. + + static List getJDOManagedFieldCountImpl(int fieldcount) + { + final List impl = new ArrayList(3); + impl.add(FIELDNAME_JDO_INHERITED_FIELD_COUNT + + " + " + fieldcount + ';'); + return impl; + } + + static List getStaticInitializerImpl(String classname, + String superPC, + String[] managedFieldNames, + String[] managedFieldTypes, + int[] managedFieldFlags) + { + classname = normalizeClassName(classname); + final List impl = new ArrayList(20); + + impl.add(ImplHelper.FIELDNAME_JDO_INHERITED_FIELD_COUNT + + " = "+ getJDOInheritedFieldCountInitValue(superPC) + ";"); + impl.add(ImplHelper.FIELDNAME_JDO_FIELD_NAMES + + " = " + getJDOFieldNamesInitValue(managedFieldNames) + ";"); + impl.add(ImplHelper.FIELDNAME_JDO_FIELD_TYPES + + " = " + getJDOFieldTypesInitValue(managedFieldTypes) + ";"); + impl.add(ImplHelper.FIELDNAME_JDO_FIELD_FLAGS + + " = " + getJDOFieldFlagsInitValue(managedFieldFlags) + ";"); + impl.add(ImplHelper.FIELDNAME_JDO_PC_SUPERCLASS + + " = " + getJDOPCSuperclassInitValue(superPC) + ";"); + + impl.add(CLASSNAME_JDO_IMPL_HELPER + + ".registerClass("); + impl.add(" " + classname + ".class" + ", "); + impl.add(" " + FIELDNAME_JDO_FIELD_NAMES + ", "); + impl.add(" " + FIELDNAME_JDO_FIELD_TYPES + ", "); + impl.add(" " + FIELDNAME_JDO_FIELD_FLAGS + ", "); + impl.add(" " + FIELDNAME_JDO_PC_SUPERCLASS + ", "); + impl.add(" " + "new " + classname + "()"); + impl.add(");"); + return impl; + } + + static List getJDOGetManagedFieldCountImpl(boolean isRoot, + String superPC, + int fieldcount) + { + superPC = normalizeClassName(superPC); + final List impl = new ArrayList(5); + if (isRoot) { + impl.add("return " + fieldcount + ';'); + } + else { + impl.add("return " + superPC + "." + + METHODNAME_JDO_GET_MANAGED_FIELD_COUNT + + "() + " + fieldcount + ';'); + } + return impl; + } + + static List getDefaultConstructorImpl() + { + final List impl = new ArrayList(5); + impl.add("super();"); + return impl; + } + + static List getDummyConstructorImpl() + { + final List impl = new ArrayList(5); + impl.add("super();"); + return impl; + } + + static List getOidStringArgConstructorImpl(String superoidclassname, + String str) + { + final List impl = new ArrayList(5); + if (superoidclassname != null) { + impl.add("super(" + str + ");"); + } + //^olsen: todo + impl.add("// not implemented yet"); + impl.add("throw new UnsupportedOperationException();"); + return impl; + } + + static List getCloneImpl(String classname) + { + classname = normalizeClassName(classname); + final List impl = new ArrayList(5); + impl.add("final " + classname + + " pc = (" + classname + ")super.clone();"); + impl.add("pc." + FIELDNAME_JDO_FLAGS + " = 0; // == READ_OK"); + impl.add("pc." + FIELDNAME_JDO_STATE_MANAGER + " = null;"); + impl.add("return pc;"); + return impl; + } + + static List getJDONewInstanceImpl(String classname, + String statemanager) + { + final List impl = new ArrayList(5); + classname = getClassName(classname); + impl.add("final " + classname + + " pc = new " + classname + "();"); + impl.add("pc." + FIELDNAME_JDO_FLAGS + " = 1; // == LOAD_REQUIRED"); + impl.add("pc." + FIELDNAME_JDO_STATE_MANAGER + + " = " + statemanager + ';'); + impl.add("return pc;"); + return impl; + } + + static List getJDONewInstanceKeyImpl(String classname, + String statemanager, + String oid) + { + final List impl = new ArrayList(5); + classname = getClassName(classname); + impl.add("final " + classname + + " pc = new " + classname + "();"); + impl.add("pc." + METHODNAME_JDO_COPY_KEY_FIELDS_FROM_OID + + "(" + oid + ");"); + impl.add("pc." + FIELDNAME_JDO_FLAGS + " = 1; // == LOAD_REQUIRED"); + impl.add("pc." + FIELDNAME_JDO_STATE_MANAGER + + " = " + statemanager + ';'); + impl.add("return pc;"); + return impl; + } + + static List getJDONewOidInstanceImpl(String oidclassname) + { + final List impl = new ArrayList(5); + if (oidclassname == null) { + impl.add("return null;"); + } else { + impl.add("return new " + oidclassname + "();"); + } + return impl; + } + + static List getJDONewOidInstanceImpl(String oidclassname, + String str) + { + final List impl = new ArrayList(5); + if (oidclassname == null) { + impl.add("return null;"); + } else { + impl.add("return new " + oidclassname + "(" + str + ");"); + } + return impl; + } + + static List getJDOCopyKeyFieldsToOid(String oidclassname, + String superoidclassname, + String oid, + String[] fieldnames) + { + final List impl = new ArrayList(5); + if (oidclassname == null) { + impl.add("return;"); + } else { + impl.add("if (!(" + oid + " instanceof " + oidclassname + ")) {"); + impl.add(" throw new IllegalArgumentException(\"arg1\");"); + impl.add("}"); + final String _oid = "_" + oid; + impl.add("final " + oidclassname + + " " + _oid + " = (" + oidclassname + ")" + oid + ";"); + if (superoidclassname != null) { + impl.add("super." + METHODNAME_JDO_COPY_KEY_FIELDS_TO_OID + + "(" + _oid + ");"); + } + for (int i = 0; i < fieldnames.length; i++) { + final String fname = fieldnames[i]; + impl.add(_oid + "." + fname + " = " + "this." + fname + ";"); + } + } + return impl; + } + + static List getJDOCopyKeyFieldsFromOid(String oidclassname, + String superoidclassname, + String oid, + String[] fieldnames) + { + final List impl = new ArrayList(5); + if (oidclassname == null) { + impl.add("return;"); + } else { + impl.add("if (!(" + oid + " instanceof " + oidclassname + ")) {"); + impl.add(" throw new IllegalArgumentException(\"arg1\");"); + impl.add("}"); + final String _oid = "_" + oid; + impl.add("final " + oidclassname + + " " + _oid + " = (" + oidclassname + ")" + oid + ";"); + if (superoidclassname != null) { + impl.add("super." + METHODNAME_JDO_COPY_KEY_FIELDS_FROM_OID + + "(" + _oid + ");"); + } + for (int i = 0; i < fieldnames.length; i++) { + final String fname = fieldnames[i]; + impl.add("this." + fname + " = " + _oid + "." + fname + ";"); + } + } + return impl; + } + + static List getJDOCopyKeyFieldsToOid(String oidclassname, + String superoidclassname, + String fm, + String oid, + String[] fieldnames, + String[] fieldtypes, + int[] fieldnumbers) + { + final List impl = new ArrayList(5); + if (oidclassname == null) { + impl.add("return;"); + } else { + impl.add("if (" + fm + " == null) {"); + impl.add(" throw new IllegalArgumentException(\"arg1\");"); + impl.add("}"); + impl.add("if (!(" + oid + " instanceof " + oidclassname + ")) {"); + impl.add(" throw new IllegalArgumentException(\"arg2\");"); + impl.add("}"); + final String _oid = "_" + oid; + impl.add("final " + oidclassname + + " " + _oid + " = (" + oidclassname + ")" + oid + ";"); + if (superoidclassname != null) { + impl.add("super." + METHODNAME_JDO_COPY_KEY_FIELDS_TO_OID + + "(" + fm + ", " + _oid + ");"); + } + for (int i = 0; i < fieldnames.length; i++) { + impl.add(_oid + "." + fieldnames[i] + " = " + fm + "." + + getMethodNameFetchField(fieldtypes[i]) + + "(" + FIELDNAME_JDO_INHERITED_FIELD_COUNT + + " + " + fieldnumbers[i] + ");"); + } + } + return impl; + } + + static List getJDOCopyKeyFieldsFromOid(String oidclassname, + String superoidclassname, + String fm, + String oid, + String[] fieldnames, + String[] fieldtypes, + int[] fieldnumbers) + { + final List impl = new ArrayList(5); + if (oidclassname == null) { + impl.add("return;"); + } else { + impl.add("if (" + fm + " == null) {"); + impl.add(" throw new IllegalArgumentException(\"arg1\");"); + impl.add("}"); + impl.add("if (!(" + oid + " instanceof " + oidclassname + ")) {"); + impl.add(" throw new IllegalArgumentException(\"arg2\");"); + impl.add("}"); + final String _oid = "_" + oid; + impl.add("final " + oidclassname + + " " + _oid + " = (" + oidclassname + ")" + oid + ";"); + if (superoidclassname != null) { + impl.add("super." + METHODNAME_JDO_COPY_KEY_FIELDS_FROM_OID + + "(" + fm + ", " + _oid + ");"); + } + for (int i = 0; i < fieldnames.length; i++) { + impl.add(fm + "." + getMethodNameStoreField(fieldtypes[i]) + + "(" + FIELDNAME_JDO_INHERITED_FIELD_COUNT + + " + " + fieldnumbers[i] + ", " + + _oid + "." + fieldnames[i] + ");"); + } + } + return impl; + } + + static List getJDOReplaceStateManagerImpl(String statemanager) + { + final List impl = new ArrayList(8); + impl.add("final " + CLASSNAME_JDO_STATE_MANAGER + + " s = this." + FIELDNAME_JDO_STATE_MANAGER + ";"); + impl.add("if (s != null) {"); + impl.add(" this." + FIELDNAME_JDO_STATE_MANAGER + + " = s.replacingStateManager(this, " + statemanager + ");"); + impl.add(" return;"); + impl.add("}"); + impl.add(CLASSNAME_JDO_IMPL_HELPER + + ".checkAuthorizedStateManager(" + statemanager + ");"); + impl.add("this." + FIELDNAME_JDO_STATE_MANAGER + + " = " + statemanager + ';'); + impl.add("this." + FIELDNAME_JDO_FLAGS + + " = LOAD_REQUIRED;"); + return impl; + } + + static List getJDOReplaceFlagsImpl() + { + final List impl = new ArrayList(5); + impl.add("final " + CLASSNAME_JDO_STATE_MANAGER + + " sm = this." + FIELDNAME_JDO_STATE_MANAGER + ";"); + impl.add("if (sm != null) {"); + impl.add(" this." + FIELDNAME_JDO_FLAGS + + " = sm.replacingFlags(this);"); + impl.add("}"); + return impl; + } + + static List getJDOFieldDirectReadImpl(String fieldname, + String fieldtype, + int fieldnumber, + String instancename) + { + fieldtype = normalizeClassName(fieldtype); + final List impl = new ArrayList(20); + impl.add("// augmentation: grant direct read access"); + impl.add("return " + instancename + '.' + fieldname + ';'); + return impl; + } + + static private void addFieldMediateReadImpl(List impl, + String fieldname, + String fieldtype, + int fieldnumber, + String instancename) + { + impl.add("final " + CLASSNAME_JDO_STATE_MANAGER + " sm = " + + instancename + '.' + FIELDNAME_JDO_STATE_MANAGER + ";"); + impl.add("if (sm == null) {"); + impl.add(" return " + instancename + '.' + fieldname + ';'); + impl.add("}"); + impl.add("if (sm.isLoaded(" + instancename + ", " + + FIELDNAME_JDO_INHERITED_FIELD_COUNT + + " + " + fieldnumber + ")) {"); + impl.add(" return " + instancename + '.' + fieldname + ';'); + impl.add("}"); + impl.add("return (" + fieldtype + ")" + + "sm." + getMethodNameGetField(fieldtype) + + "(" + instancename + ", " + + FIELDNAME_JDO_INHERITED_FIELD_COUNT + + " + " + fieldnumber + ", " + + instancename + '.' + fieldname + ");"); + } + + static List getJDOFieldMediateReadImpl(String fieldname, + String fieldtype, + int fieldnumber, + String instancename) + { + fieldtype = normalizeClassName(fieldtype); + final List impl = new ArrayList(20); + impl.add("// augmentation: mediate read access"); + addFieldMediateReadImpl(impl, fieldname, fieldtype, + fieldnumber, instancename); + return impl; + } + + static List getJDOFieldCheckReadImpl(String fieldname, + String fieldtype, + int fieldnumber, + String instancename) + { + fieldtype = normalizeClassName(fieldtype); + final List impl = new ArrayList(20); + impl.add("// augmentation: check read access"); + impl.add("if (" + instancename + '.' + FIELDNAME_JDO_FLAGS + + " <= 0) {"); + impl.add(" return " + instancename + '.' + fieldname + ';'); + impl.add("}"); + addFieldMediateReadImpl(impl, fieldname, fieldtype, + fieldnumber, instancename); + return impl; + } + + static List getJDOFieldDirectWriteImpl(String fieldname, + String fieldtype, + int fieldnumber, + String instancename, + String newvalue) + { + fieldtype = normalizeClassName(fieldtype); + final List impl = new ArrayList(20); + impl.add("// augmentation: grant direct write access"); + impl.add(instancename + '.' + fieldname + + " = " + newvalue + ';'); + return impl; + } + + static private void addFieldMediateWriteImpl(List impl, + String fieldname, + String fieldtype, + int fieldnumber, + String instancename, + String newvalue) + { + impl.add("final " + CLASSNAME_JDO_STATE_MANAGER + " sm = " + + instancename + '.' + FIELDNAME_JDO_STATE_MANAGER + ";"); + impl.add("if (sm == null) {"); + impl.add(" " + instancename + '.' + fieldname + + " = " + newvalue + ';'); + impl.add(" return;"); + impl.add("}"); + impl.add("sm." + + getMethodNameSetField(fieldtype) + + "(" + instancename + ", " + + FIELDNAME_JDO_INHERITED_FIELD_COUNT + + " + " + fieldnumber + ", " + + instancename + + '.' + fieldname + ", " + + newvalue + ");"); + } + + static List getJDOFieldMediateWriteImpl(String fieldname, + String fieldtype, + int fieldnumber, + String instancename, + String newvalue) + { + fieldtype = normalizeClassName(fieldtype); + final List impl = new ArrayList(20); + impl.add("// augmentation: mediate write access"); + addFieldMediateWriteImpl(impl, fieldname, fieldtype, + fieldnumber, instancename, newvalue); + return impl; + } + + static List getJDOFieldCheckWriteImpl(String fieldname, + String fieldtype, + int fieldnumber, + String instancename, + String newvalue) + { + fieldtype = normalizeClassName(fieldtype); + final List impl = new ArrayList(20); + impl.add("// augmentation: check write access"); + impl.add("if (" + instancename + + '.' + FIELDNAME_JDO_FLAGS + " == 0) {"); + impl.add(" " + instancename + '.' + fieldname + + " = " + newvalue + ';'); + impl.add(" return;"); + impl.add("}"); + addFieldMediateWriteImpl(impl, fieldname, fieldtype, + fieldnumber, instancename, newvalue); + return impl; + } + + static List getJDOReplaceFieldImpl(String fieldnumber, + boolean isRoot, + String[] fieldnames, + String[] fieldtypes) + { + final List impl = new ArrayList(20); + impl.add("final " + CLASSNAME_JDO_STATE_MANAGER + " sm = this." + + FIELDNAME_JDO_STATE_MANAGER + ";"); + impl.add("switch (" + fieldnumber + + " - " + FIELDNAME_JDO_INHERITED_FIELD_COUNT + ") {"); + for (int i = 0; i < fieldnames.length; i++) { + String fieldtype = normalizeClassName(fieldtypes[i]); + impl.add("case " + i + ':'); + impl.add(" if (sm == null) {"); + impl.add(" throw new IllegalStateException(\"arg0." + + FIELDNAME_JDO_STATE_MANAGER + "\");"); + impl.add(" }"); + impl.add(" this." + fieldnames[i] + + " = (" + fieldtype + ")sm." + + getMethodNameReplacingField(fieldtype) + + "(this, " + fieldnumber + ");"); + impl.add(" return;"); + } + impl.add("default:"); + if (isRoot) { + impl.add(" throw new IllegalArgumentException(\"arg1\");"); + } else { + impl.add(" super." + METHODNAME_JDO_REPLACE_FIELD + + "(" + fieldnumber + ");"); + } + impl.add("}"); + return impl; + } + + static List getJDOProvideFieldImpl(String fieldnumber, + boolean isRoot, + String[] fieldnames, + String[] fieldtypes) + { + final List impl = new ArrayList(20); + impl.add("final " + CLASSNAME_JDO_STATE_MANAGER + " sm = this." + + FIELDNAME_JDO_STATE_MANAGER + ";"); + impl.add("switch (" + fieldnumber + + " - " + FIELDNAME_JDO_INHERITED_FIELD_COUNT + ") {"); + for (int i = 0; i < fieldnames.length; i++) { + String fieldtype = normalizeClassName(fieldtypes[i]); + impl.add("case " + i + ':'); + impl.add(" if (sm == null) {"); + impl.add(" throw new IllegalStateException(\"arg0." + + FIELDNAME_JDO_STATE_MANAGER + "\");"); + impl.add(" }"); + impl.add(" sm." + getMethodNameProvidedField(fieldtype) + + "(this, " + fieldnumber + ", " + + "this." + fieldnames[i] + ");"); + impl.add(" return;"); + } + impl.add("default:"); + if (isRoot) { + impl.add(" throw new IllegalArgumentException(\"arg1\");"); + } else { + impl.add(" super." + METHODNAME_JDO_PROVIDE_FIELD + + "(" + fieldnumber + ");"); + } + impl.add("}"); + return impl; + } + + static List getJDOCopyFieldsImpl(String classname, + String copy, + String fieldnumbers) + { + classname = normalizeClassName(classname); + final List impl = new ArrayList(50); + impl.add("if (this." + FIELDNAME_JDO_STATE_MANAGER + " == null) {"); + impl.add(" throw new IllegalStateException(\"arg0." + + FIELDNAME_JDO_STATE_MANAGER + "\");"); + impl.add("}"); + impl.add("if (!(" + copy + " instanceof " + classname + ")) {"); + impl.add(" throw new IllegalArgumentException(\"arg1\");"); + impl.add("}"); + impl.add("if (" + fieldnumbers + " == null) {"); + impl.add(" throw new IllegalArgumentException(\"arg2\");"); + impl.add("}"); + impl.add("final " + classname + + " other = (" + classname + ")" + copy + ';'); + impl.add("if (other." + FIELDNAME_JDO_STATE_MANAGER + + " != this." + FIELDNAME_JDO_STATE_MANAGER + ") {"); + impl.add(" throw new IllegalArgumentException(\"" + + "arg1." + FIELDNAME_JDO_STATE_MANAGER + "\");"); + impl.add("}"); + impl.add("final int n = " + fieldnumbers + ".length;"); + impl.add("for (int i = 0; i < n; i++) {"); + impl.add(" this." + METHODNAME_JDO_COPY_FIELD + + "(other, " + fieldnumbers + "[i]);"); + impl.add("}"); + return impl; + } + + static List getJDOCopyFieldImpl(String classname, + String copy, + String fieldnumber, + String[] fieldnames, + boolean isRoot) + { + classname = normalizeClassName(classname); + final List impl = new ArrayList(50); + impl.add("switch (" + fieldnumber + + " - " + FIELDNAME_JDO_INHERITED_FIELD_COUNT + ") {"); + for (int i = 0; i < fieldnames.length; i++) { + impl.add("case " + i + ':'); + impl.add(" if (" + copy + " == null) {"); + impl.add(" throw new IllegalArgumentException(\"arg1\");"); + impl.add(" }"); + impl.add(" this." + fieldnames[i] + + " = " + copy + "." + fieldnames[i] + ';'); + impl.add(" return;"); + } + impl.add("default:"); + if (isRoot) { + impl.add(" throw new IllegalArgumentException(\"arg2\");"); + } else { + impl.add(" super." + METHODNAME_JDO_COPY_FIELD + + "(" + copy + ", " + fieldnumber + ");"); + } + impl.add("}"); + return impl; + } + + static List getWriteObjectImpl(String out) + { + final List impl = new ArrayList(5); + impl.add(METHODNAME_JDO_PRE_SERIALIZE + "();"); + impl.add(out + ".defaultWriteObject();"); + + return impl; + } + + static List getJDOStateManagerVoidDelegationImpl(String delegation) + { + final List impl = new ArrayList(5); + impl.add("final " + CLASSNAME_JDO_STATE_MANAGER + + " sm = this." + FIELDNAME_JDO_STATE_MANAGER + ";"); + impl.add("if (sm != null) {"); + impl.add(" sm." + delegation + ';'); + impl.add("}"); + return impl; + + } + + static List getJDOStateManagerObjectDelegationImpl(String delegation) + { + final List impl = new ArrayList(5); + impl.add("final " + CLASSNAME_JDO_STATE_MANAGER + + " sm = this." + FIELDNAME_JDO_STATE_MANAGER + ";"); + impl.add("if (sm != null) {"); + impl.add(" return sm." + delegation + ';'); + impl.add("}"); + impl.add("return null;"); + return impl; + } + + static List getJDOStateManagerBooleanDelegationImpl(String delegation) + { + final List impl = new ArrayList(5); + impl.add("final " + CLASSNAME_JDO_STATE_MANAGER + + " sm = this." + FIELDNAME_JDO_STATE_MANAGER + ";"); + impl.add("if (sm != null) {"); + impl.add(" return sm." + delegation + ';'); + impl.add("}"); + impl.add("return false;"); + return impl; + } + + static List getJDOFieldIterationImpl(String fieldnumbers, + String method) + { + final List impl = new ArrayList(10); + impl.add("if (" + fieldnumbers + " == null) {"); + impl.add(" throw new IllegalArgumentException(\"arg1\");"); + impl.add("}"); + impl.add("final int n = " + fieldnumbers + ".length;"); + impl.add("for (int i = 0; i < n; i++) {"); + impl.add(" this." + method + "(" + fieldnumbers + "[i]);"); + impl.add("}"); + return impl; + } + + static List getOidHashCodeImpl(String[] pknames, + String[] pktypes, + boolean isRoot) + { + final List impl = new ArrayList(3); + if (isRoot) { + impl.add("int hash = 0;"); + } else { + impl.add("int hash = super.hashCode();"); + } + for (int i = 0; i < pknames.length; i++) { + if (isPrimitiveClass(pktypes[i])) { + if (pktypes[i].equals("boolean")) { + impl.add("hash += (" + pknames[i] + " ? 1 : 0);"); + } else { + impl.add("hash += (int)" + pknames[i] + ';'); + } + } else { + impl.add("hash += (this." + pknames[i] + + " != null ? this." + pknames[i] + + ".hashCode() : 0);"); + } + } + impl.add("return hash;"); + return impl; + } + + static List getOidEqualsImpl(String oidclassname, + String[] pknames, + String[] pktypes, + String pk, + boolean isRoot) + { + final List impl = new ArrayList(3); + if (isRoot) { + impl.add("if (" + pk + " == null || !this.getClass().equals(" + + pk + ".getClass())) {"); + } else { + impl.add("if (!super.equals(" + pk + ")) {"); + } + impl.add(" return false;"); + impl.add("}"); + oidclassname = getClassName(oidclassname); + impl.add(oidclassname + " oid = (" + oidclassname + ")" + pk + ';'); + for (int i = 0; i < pknames.length; i++) { + if (isPrimitiveClass(pktypes[i])) { + impl.add("if (this." + pknames[i] + " != oid." + + pknames[i] + ") return false;"); + } else { + impl.add("if (this." + pknames[i] + " != oid." + + pknames[i] + " && (this." + pknames[i] + + " == null || " + "!this." + pknames[i] + + ".equals(oid." + pknames[i] + + "))) return false;"); + } + } + impl.add("return true;"); + return impl; + } + + static private boolean isPrimitiveClass(String classname) + { + return (classname.equals("int") + || classname.equals("long") + || classname.equals("short") + || classname.equals("byte") + || classname.equals("boolean") + || classname.equals("char") + || classname.equals("double") + || classname.equals("float")); + } +}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/Main.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/Main.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/Main.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/Main.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,1138 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.jdo.impl.enhancer.generator; + +import java.lang.reflect.Modifier; + +import java.util.Iterator; +import java.util.Collection; +import java.util.List; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Properties; + +import java.io.Serializable; +import java.io.File; +import java.io.Writer; +import java.io.PrintWriter; +import java.io.FileWriter; +import java.io.BufferedWriter; +import java.io.InputStream; +import java.io.BufferedInputStream; +import java.io.FileInputStream; +import java.io.ObjectOutputStream; +import java.io.IOException; +import java.io.FileNotFoundException; + +import org.apache.jdo.impl.enhancer.meta.ExtendedMetaData; +import org.apache.jdo.impl.enhancer.meta.prop.EnhancerMetaDataPropertyImpl; +import org.apache.jdo.impl.enhancer.util.Support; + + + + +/** + * + */ +public final class Main + extends Support +{ + /** + * The stream to write messages to. + */ + private final PrintWriter out = new PrintWriter(System.out, true); + + /** + * The stream to write error messages to. + */ + private final PrintWriter err = new PrintWriter(System.err, true); + + /** + * The command line options. + */ + private final CmdLineOptions opts = new CmdLineOptions(); + + /** + * + */ + private final CodeWriter writer = new CodeWriter(); + + /** + * The MetaData for generating classes. + */ + private ExtendedMetaData meta = null; + + /** + * + */ + public Main() + {} + + /** + * + */ + public static final void main(String[] argv) + { + final Main gen = new Main(); + try { + gen.opts.processArgs(argv); + gen.init(); + gen.generate(); + } catch(Exception ex) { + gen.printError(null, ex); + } + } + + /** + * A class for holding the command line options. + */ + private class CmdLineOptions + { + // final Collection inputFileNames = new ArrayList(); + String destinationDirectory = null; + String jdoXMLModelFileName = null; + String jdoPropertiesFileName = null; + boolean verbose = false; + boolean quiet = false; + boolean forceWrite = false; + boolean noWrite = false; + + /** + * Print a usage message to System.err + */ + public void usage() { + err.println("Usage: Main <options> <arguments>..."); + err.println("Options:"); + err.println(" -v, --verbose print verbose output"); +/* + err.println(" -q, --quiet supress warnings"); + err.println(" -n, --nowrite never write classfiles"); + err.println(" -f, --force ever write classfiles"); +*/ + err.println(" -d, --dest <dir> destination directory for output files"); + err.println(" -p, --properties <file> use property file for meta data"); +/* + err.println(" -x, --xmlmodel <file> use JDO XML model file for meta data"); +*/ + err.println(); + err.println("Arguments:"); + err.println(); + err.println("Returns a non-zero value in case of errors."); + System.exit(1); + } + + /** + * Process command line options + */ + protected int processArgs(String[] argv) + { + for (int i = 0; i < argv.length; i++) { + final String arg = argv[i]; + if (arg.equals("-v") + || arg.equals("--verbose")) { + verbose = true; + quiet = false; + continue; + } +/* + if (arg.equals("-q") + || arg.equals("--quiet")) { + quiet = true; + verbose = false; + continue; + } + if (arg.equals("-f") + || arg.equals("--force")) { + forceWrite = true; + continue; + } + if (arg.equals("-n") + || arg.equals("--nowrite")) { + noWrite = true; + continue; + } +*/ + if (arg.equals("-d") + || arg.equals("--dest")) { + if (argv.length - i < 2) { + printError("Missing argument to the -d/-dest option", null); + usage(); + } + destinationDirectory = argv[++i]; + continue; + } + if (arg.equals("-p") || + arg.equals("--properties")) { + if (argv.length - i < 2) { + printError("Missing argument to the -p/--properties option", null); + usage(); + } + jdoPropertiesFileName = argv[++i]; + continue; + } +/* + if (arg.equals("-x") || + arg.equals("--xmlmodel")) { + if (argv.length - i < 2) { + printError("Missing argument to the -p/--properties option", null); + usage(); + } + jdoXMLModelFileName = argv[++i]; + continue; + } +*/ + if (arg.length() > 0 && arg.charAt(0) == '-') { + printError("Unrecognized option:" + arg, null); + usage(); + } + if (arg.length() == 0) { + printMessage("Ignoring empty command line argument."); + continue; + } + + //inputFileNames.add(arg); + } + + // The user must specify a destination directory + if (jdoPropertiesFileName == null) { + printError("No destination directory specified", null); + usage(); + } + + // The user must specify a destination directory + if (destinationDirectory == null) { + printError("No destination directory specified", null); + usage(); + } + + return 0; + } + } + + private void init() + throws FileNotFoundException, IOException + { + // load the properties + affirm(opts.jdoPropertiesFileName != null); + meta = new EnhancerMetaDataPropertyImpl(out, opts.verbose, + opts.jdoPropertiesFileName); + + // create the destination directory + affirm(opts.destinationDirectory != null); + final File destinationDir = new File(opts.destinationDirectory); + boolean res = destinationDir.mkdirs(); + if (!res) { + throw new IOException("unable to create destination directory: " + + "'" + destinationDir + "'"); + } + } + + private void generate() + { + final String[] classes = meta.getKnownClasses(); + for (int i = 0; i < classes.length; i++) { + final String classname = classes[i]; + try { + if (classname.indexOf('$') != -1) { + printMessage("Skipping generation of nested class " + classname + "." + + " Note, a nested ObjectId class is generated with its pc class."); + continue; + } + final Writer writer = createFileWriter(classname); + this.writer.setWriter(writer); + generateClass(classname); + writer.close(); + } catch(IOException ex) { + printError("Error generating class '" + classname + "'.", ex); + } + } + } + + private void generateClass(final String classname) + throws IOException + { + affirm(classname); + + final String normClassName = NameHelper.normalizeClassName(classname); + printMessage("generating '" + normClassName + "'..."); + + final String packageName = NameHelper.getPackageName(classname); + writer.writePackage( + packageName, + null); + + writer.writeImports( + null, + null); + + // write the class header and key class + final String oidClassName = meta.getKeyClass(classname); + if (oidClassName == null) { + writeClassHeader(classname); + } else { + final String oidPackageName + = NameHelper.getPackageName(oidClassName); + affirm(packageName.equals(oidPackageName), + "PC class and key class must be in same package."); + + final boolean enclosedOid + = oidClassName.startsWith(classname + "$"); + if (enclosedOid) { + writeClassHeader(classname); + writeOidClass(classname, oidClassName, enclosedOid); + } else { + writeOidClass(classname, oidClassName, enclosedOid); + writeClassHeader(classname); + } + } + + writeClassMembers(classname); + + // write the augmentation + final boolean isPC = meta.isPersistenceCapableClass(classname); + if (isPC) { + final boolean isPCRoot + = meta.isPersistenceCapableRootClass(classname); + if (isPCRoot) { + writePCRootMembers(classname); + } + writePCMembers(classname); + + writeClassMemberAccessors(classname); + } + + writer.writeClassEnd(); + } + + private Writer createFileWriter(String classname) + throws IOException + { + final File file = new File(opts.destinationDirectory, + classname + ".java"); + file.getAbsoluteFile().getParentFile().mkdirs(); + return new BufferedWriter(new FileWriter(file)); + } + + private void writeClassHeader(final String classname) + throws IOException + { + final boolean isPCRoot = meta.isPersistenceCapableRootClass(classname); + final String superclass = meta.getSuperClass(classname); + + String[] interfaces = null; + String[] comments = null; + interfaces + = new String[]{ ImplHelper.CLASSNAME_JDO_PERSISTENCE_CAPABLE }; + writer.writeClassHeader(meta.getClassModifiers(classname), + ImplHelper.getClassName(classname), + superclass, + interfaces, + comments); + } + + private void writeClassMembers(final String classname) + throws IOException + { + writer.writeComments(1, new String[]{ + "----------------------------------------------------------------------", + "Class Members:", + "----------------------------------------------------------------------" + }); + writer.writeln(); + + // write default constructor + writer.writeConstructor( + ImplHelper.getClassName(classname), + Modifier.PUBLIC, + null, null, null, + ImplHelper.getDefaultConstructorImpl(), + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + + // write default constructor + writer.writeConstructor( + ImplHelper.getClassName(classname), + Modifier.PUBLIC, + new String[]{ "str" }, + new String[]{ "String" }, + null, + ImplHelper.getDummyConstructorImpl(), + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + + final String[] fieldnames = meta.getKnownFields(classname); + final int n = (fieldnames != null ? fieldnames.length : 0); + + // write the fields and with their bean getters/setters + for (int i = 0; i < n; i++) { + final String fieldname = (String)fieldnames[i]; + writeFieldMember(classname, fieldname); + } + } + + private void writeFieldMember(final String classname, + final String fieldname) + throws IOException + { + final String fieldtype = meta.getFieldType(classname, fieldname); + final int access = meta.getFieldModifiers(classname, fieldname); + final String normClassName = NameHelper.normalizeClassName(classname); + final List impl = new ArrayList(); + + // the field + writer.writeField( + fieldname, + access, + fieldtype, + null, null); + + // do not write bean getters and setters for static fields + if ((access & Modifier.STATIC) != 0) { + return; + } + + // write bean getter (calling accessor) + impl.clear(); + impl.add("//return this." + fieldname + ';'); + final String accessor + = ImplHelper.createJDOFieldAccessorName(classname, fieldname); + impl.add("return " + normClassName + "." + accessor + "(this);"); + writer.writeMethod( + createMethodName("get", fieldname), + Modifier.PUBLIC, + fieldtype, + null, + null, + null, + impl, + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + + // write bean setter (calling mutator) + impl.clear(); + impl.add("//this." + fieldname + " = " + fieldname + ';'); + final String mutator + = ImplHelper.createJDOFieldMutatorName(classname, fieldname); + impl.add(normClassName + "." + mutator + "(this, " + fieldname + ");"); + writer.writeMethod( + createMethodName("set", fieldname), + Modifier.PUBLIC, + "void", + new String[]{ fieldname }, + new String[]{ fieldtype }, + null, + impl, + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + } + + private void writeClassMemberAccessors(final String classname) + throws IOException + { + writer.writeComments(1, new String[]{ + "----------------------------------------------------------------------", + "Augmentation for Field Accessors and Mutators (added by enhancer):", + "----------------------------------------------------------------------" + }); + writer.writeln(); + + // write the fields and their access methods + final String[] fields = meta.getManagedFields(classname); + final int n = (fields != null ? fields.length : 0); + for (int i = 0; i < n; i++) { + final String fieldname = (String)fields[i]; + writeFieldAccessors(classname, fieldname); + } + } + + private void writeFieldAccessors(final String classname, + final String fieldname) + throws IOException + { + final String fieldtype + = meta.getFieldType(classname, fieldname); + final int fieldnumber + = meta.getFieldNumber(classname, fieldname); + final boolean dfg + = meta.isDefaultFetchGroupField(classname, fieldname); + final int access + = meta.getFieldModifiers(classname, fieldname); + final int flags + = meta.getFieldFlags(classname, fieldname); + + final String accessor + = ImplHelper.createJDOFieldAccessorName(classname, fieldname); + final String mutator + = ImplHelper.createJDOFieldMutatorName(classname, fieldname); + + final String instancename + = "instance"; + + // jdo accessor + { + affirm(((flags & meta.CHECK_READ) == 0) + | (flags & meta.MEDIATE_READ) == 0); + final List impl; + if ((flags & meta.CHECK_READ) != 0) { + impl = ImplHelper.getJDOFieldCheckReadImpl(fieldname, + fieldtype, + fieldnumber, + instancename); + } else if ((flags & meta.MEDIATE_READ) != 0) { + impl = ImplHelper.getJDOFieldMediateReadImpl(fieldname, + fieldtype, + fieldnumber, + instancename); + } else { + impl = ImplHelper.getJDOFieldDirectReadImpl(fieldname, + fieldtype, + fieldnumber, + instancename); + } + writer.writeMethod( + accessor, + access | Modifier.STATIC | Modifier.FINAL, + fieldtype, + new String[]{ instancename }, + new String[]{ classname }, + null, + impl, + ImplHelper.COMMENT_ENHANCER_ADDED); + } + + // jdo mutator + { + affirm(((flags & meta.CHECK_WRITE) == 0) + | (flags & meta.MEDIATE_WRITE) == 0); + final List impl; + if ((flags & meta.CHECK_WRITE) != 0) { + impl = ImplHelper.getJDOFieldCheckWriteImpl(fieldname, + fieldtype, + fieldnumber, + instancename, + fieldname); + } else if ((flags & meta.MEDIATE_WRITE) != 0) { + impl = ImplHelper.getJDOFieldMediateWriteImpl(fieldname, + fieldtype, + fieldnumber, + instancename, + fieldname); + } else { + impl = ImplHelper.getJDOFieldDirectWriteImpl(fieldname, + fieldtype, + fieldnumber, + instancename, + fieldname); + } + writer.writeMethod( + mutator, + access | Modifier.STATIC | Modifier.FINAL, + "void", + new String[]{ instancename, fieldname }, + new String[]{ classname, fieldtype }, + null, + impl, + ImplHelper.COMMENT_ENHANCER_ADDED); + } + } + + private void writePCRootMembers(final String classname) + throws IOException + { + writer.writeComments(1, new String[]{ + "----------------------------------------------------------------------", + "Augmentation for Persistence-Capable Root Classes (added by enhancer):", + "----------------------------------------------------------------------" + }); + writer.writeln(); + + // jdoStateManager + writer.writeField( + ImplHelper.FIELDNAME_JDO_STATE_MANAGER, + Modifier.PROTECTED | Modifier.TRANSIENT, + ImplHelper.CLASSNAME_JDO_STATE_MANAGER, + "null", + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoFlags + writer.writeField( + ImplHelper.FIELDNAME_JDO_FLAGS, + Modifier.PROTECTED | Modifier.TRANSIENT, + "byte", + "0", // (ImplHelper.CLASSNAME_JDO_PERSISTENCE_CAPABLE + // + "." + "READ_WRITE_OK"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoReplaceStateManager + writer.writeMethod( + ImplHelper.METHODNAME_JDO_REPLACE_STATE_MANAGER, + Modifier.PUBLIC | Modifier.FINAL | Modifier.SYNCHRONIZED, + "void", + new String[]{ "sm" }, + new String[]{ ImplHelper.CLASSNAME_JDO_STATE_MANAGER }, + null, + ImplHelper.getJDOReplaceStateManagerImpl("sm"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoReplaceFlags + writer.writeMethod( + ImplHelper.METHODNAME_JDO_REPLACE_FLAGS, + Modifier.PUBLIC | Modifier.FINAL, + "void", null, null, null, + ImplHelper.getJDOReplaceFlagsImpl(), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // getPersistenceManager + writer.writeMethod( + ImplHelper.METHODNAME_JDO_GET_PERSISTENCE_MANAGER, + Modifier.PUBLIC | Modifier.FINAL, + ImplHelper.CLASSNAME_JDO_PERSISTENCE_MANAGER, null, null, null, + ImplHelper.getJDOStateManagerObjectDelegationImpl("getPersistenceManager(this)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // getObjectId + writer.writeMethod( + ImplHelper.METHODNAME_JDO_GET_OBJECT_ID, + Modifier.PUBLIC | Modifier.FINAL, + Object.class.getName(), null, null, null, + ImplHelper.getJDOStateManagerObjectDelegationImpl("getObjectId(this)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_JDO_GET_TRANSACTIONAL_OBJECT_ID, + Modifier.PUBLIC | Modifier.FINAL, + Object.class.getName(), null, null, null, + ImplHelper.getJDOStateManagerObjectDelegationImpl("getTransactionalObjectId(this)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // is-methods + writer.writeMethod( + ImplHelper.METHODNAME_JDO_IS_PERSISTENT, + Modifier.PUBLIC | Modifier.FINAL, + "boolean", null, null, null, + ImplHelper.getJDOStateManagerBooleanDelegationImpl("isPersistent(this)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_JDO_IS_TRANSACTIONAL, + Modifier.PUBLIC | Modifier.FINAL, + "boolean", null, null, null, + ImplHelper.getJDOStateManagerBooleanDelegationImpl("isTransactional(this)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_JDO_IS_NEW, + Modifier.PUBLIC | Modifier.FINAL, + "boolean", null, null, null, + ImplHelper.getJDOStateManagerBooleanDelegationImpl("isNew(this)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_JDO_IS_DELETED, + Modifier.PUBLIC | Modifier.FINAL, + "boolean", null, null, null, + ImplHelper.getJDOStateManagerBooleanDelegationImpl("isDeleted(this)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_JDO_IS_DIRTY, + Modifier.PUBLIC | Modifier.FINAL, + "boolean", null, null, null, + ImplHelper.getJDOStateManagerBooleanDelegationImpl("isDirty(this)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // makeDirty + writer.writeMethod( + ImplHelper.METHODNAME_JDO_MAKE_DIRTY, + Modifier.PUBLIC | Modifier.FINAL, + "void", + new String[]{ "fieldname" }, + new String[]{ String.class.getName() }, + null, + ImplHelper.getJDOStateManagerVoidDelegationImpl("makeDirty(this, fieldname)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // replaceFields + writer.writeMethod( + ImplHelper.METHODNAME_JDO_REPLACE_FIELDS, + Modifier.PUBLIC | Modifier.FINAL, + "void", + new String[]{ "fieldnumbers" }, + new String[]{ "int[]" }, + null, + ImplHelper.getJDOFieldIterationImpl("fieldnumbers", + ImplHelper.METHODNAME_JDO_REPLACE_FIELD), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // provideFields + writer.writeMethod( + ImplHelper.METHODNAME_JDO_PROVIDE_FIELDS, + Modifier.PUBLIC | Modifier.FINAL, + "void", + new String[]{ "fieldnumbers" }, + new String[]{ "int[]" }, + null, + ImplHelper.getJDOFieldIterationImpl("fieldnumbers", + ImplHelper.METHODNAME_JDO_PROVIDE_FIELD), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // preSerialize + writer.writeMethod( + ImplHelper.METHODNAME_JDO_PRE_SERIALIZE, + Modifier.PROTECTED | Modifier.FINAL, + "void", null, null, null, + ImplHelper.getJDOStateManagerVoidDelegationImpl("preSerialize(this)"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // write method clone() + writer.writeMethod( + "clone", + Modifier.PUBLIC, + "Object", + null, + null, + new String[]{ "java.lang.CloneNotSupportedException" }, + ImplHelper.getCloneImpl(classname), + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + + } + + private void writePCMembers(final String classname) + throws IOException + { + writer.writeComments(1, new String[]{ + "----------------------------------------------------------------------", + "Augmentation for Persistence-Capable Classes (added by enhancer):", + "----------------------------------------------------------------------" + }); + writer.writeln(); + + final String[] managedFieldNames + = meta.getManagedFields(classname); + final String[] managedFieldTypes + = meta.getFieldType(classname, managedFieldNames); + final boolean isPCRoot + = meta.isPersistenceCapableRootClass(classname); + + writePCStaticMembers(classname); + + // jdoNewInstance + writer.writeMethod( + ImplHelper.METHODNAME_JDO_NEW_INSTANCE, + Modifier.PUBLIC, + ImplHelper.CLASSNAME_JDO_PERSISTENCE_CAPABLE, + new String[]{ "sm" }, + new String[]{ ImplHelper.CLASSNAME_JDO_STATE_MANAGER }, + null, + ImplHelper.getJDONewInstanceImpl(classname, + "sm"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoNewInstance + writer.writeMethod( + ImplHelper.METHODNAME_JDO_NEW_INSTANCE, + Modifier.PUBLIC, + ImplHelper.CLASSNAME_JDO_PERSISTENCE_CAPABLE, + new String[]{ "sm", "oid" }, + new String[]{ ImplHelper.CLASSNAME_JDO_STATE_MANAGER, "Object" }, + null, + ImplHelper.getJDONewInstanceKeyImpl(classname, + //oidClassName, + "sm", + "oid"), + //keyFieldNames), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoReplaceField + writer.writeMethod( + ImplHelper.METHODNAME_JDO_REPLACE_FIELD, + Modifier.PUBLIC, + "void", + new String[]{ "fieldnumber" }, + new String[]{ "int" }, + null, + ImplHelper.getJDOReplaceFieldImpl("fieldnumber", + isPCRoot, + managedFieldNames, + managedFieldTypes), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoProvideField(s) + writer.writeMethod( + ImplHelper.METHODNAME_JDO_PROVIDE_FIELD, + Modifier.PUBLIC, + "void", + new String[]{ "fieldnumber" }, + new String[]{ "int" }, + null, + ImplHelper.getJDOProvideFieldImpl("fieldnumber", + isPCRoot, + managedFieldNames, + managedFieldTypes), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoCopyFields + writer.writeMethod( + ImplHelper.METHODNAME_JDO_COPY_FIELDS, + Modifier.PUBLIC, + "void", + new String[]{ "pc", "fieldnumbers" }, + new String[]{ Object.class.getName(), "int[]" }, + null, + ImplHelper.getJDOCopyFieldsImpl(classname, + "pc", + "fieldnumbers"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoCopyField + writer.writeMethod( + ImplHelper.METHODNAME_JDO_COPY_FIELD, + Modifier.PROTECTED | Modifier.FINAL, + "void", + new String[]{ "pc", "fieldnumber" }, + new String[]{ classname, "int" }, + null, + ImplHelper.getJDOCopyFieldImpl(classname, + "pc", + "fieldnumber", + managedFieldNames, + isPCRoot), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writePCKeyHandlingMembers(classname); + + writePCSerializationMembers(classname); + } + + private void writePCStaticMembers(final String classname) + throws IOException + { + final String[] managedFieldNames + = meta.getManagedFields(classname); + final String superPC + = meta.getPersistenceCapableSuperClass(classname); + final String[] managedFieldTypes + = meta.getFieldType(classname, managedFieldNames); + final int[] managedFieldFlags + = meta.getFieldFlags(classname, managedFieldNames); + final boolean isPCRoot + = meta.isPersistenceCapableRootClass(classname); + + // inheritedFieldCount + writer.writeField( + ImplHelper.FIELDNAME_JDO_INHERITED_FIELD_COUNT, + Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL, + "int", + null, + ImplHelper.COMMENT_ENHANCER_ADDED); + + // fieldNames + writer.writeField( + ImplHelper.FIELDNAME_JDO_FIELD_NAMES, + Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL, + "String[]", + null, + ImplHelper.COMMENT_ENHANCER_ADDED); + + // fieldTypes + writer.writeField( + ImplHelper.FIELDNAME_JDO_FIELD_TYPES, + Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL, + "Class[]", + null, + ImplHelper.COMMENT_ENHANCER_ADDED); + + // fieldFlags + writer.writeField( + ImplHelper.FIELDNAME_JDO_FIELD_FLAGS, + Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL, + "byte[]", + null, + ImplHelper.COMMENT_ENHANCER_ADDED); + + // PC superclass + writer.writeField( + ImplHelper.FIELDNAME_JDO_PC_SUPERCLASS, + Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL, + "Class", + null, + ImplHelper.COMMENT_ENHANCER_ADDED); + + // static initializer + writer.writeStaticInitializer( + ImplHelper.getStaticInitializerImpl(classname, + superPC, + managedFieldNames, + managedFieldTypes, + managedFieldFlags), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoGetManagedFieldCount + writer.writeMethod( + ImplHelper.METHODNAME_JDO_GET_MANAGED_FIELD_COUNT, + Modifier.PROTECTED | Modifier.STATIC, + "int", null, null, null, + ImplHelper.getJDOGetManagedFieldCountImpl( + isPCRoot, superPC, managedFieldNames.length), + ImplHelper.COMMENT_ENHANCER_ADDED); + } + + private void writePCKeyHandlingMembers(final String classname) + throws IOException + { + final boolean isPCRoot + = meta.isPersistenceCapableRootClass(classname); + final String oidClassName + = NameHelper.normalizeClassName(meta.getKeyClass(classname)); + + // generate these methods if this is the PC root class or if + // there's a key class definition + if (!isPCRoot && oidClassName == null) { + return; + } + + final String superOidClassName + = NameHelper.normalizeClassName(meta.getSuperKeyClass(classname)); + final String[] keyFieldNames + = meta.getKeyFields(classname); + final String[] keyFieldTypes + = meta.getFieldType(classname, keyFieldNames); + final int[] keyFieldNumbers + = meta.getFieldNumber(classname, keyFieldNames); + + // jdoNewOidInstance + writer.writeMethod( + ImplHelper.METHODNAME_JDO_NEW_OID_INSTANCE, + Modifier.PUBLIC, + Object.class.getName(), null, null, null, + ImplHelper.getJDONewOidInstanceImpl(oidClassName), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_JDO_NEW_OID_INSTANCE, + Modifier.PUBLIC, + Object.class.getName(), + new String[]{ "str" }, + new String[]{ "String" }, + null, + ImplHelper.getJDONewOidInstanceImpl(oidClassName, + "str"), + ImplHelper.COMMENT_ENHANCER_ADDED); + + // jdoCopyKeyFieldsTo/FromOid + writer.writeMethod( + ImplHelper.METHODNAME_JDO_COPY_KEY_FIELDS_TO_OID, + Modifier.PUBLIC, + "void", + new String[]{ "oid" }, + new String[]{ "Object" }, + null, + ImplHelper.getJDOCopyKeyFieldsToOid(oidClassName, + superOidClassName, + "oid", + keyFieldNames), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_JDO_COPY_KEY_FIELDS_FROM_OID, + Modifier.PROTECTED, + "void", + new String[]{ "oid" }, + new String[]{ "Object" }, + null, + ImplHelper.getJDOCopyKeyFieldsFromOid(oidClassName, + superOidClassName, + "oid", + keyFieldNames), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_JDO_COPY_KEY_FIELDS_TO_OID, + Modifier.PUBLIC, + "void", + new String[]{ "ofs", "oid" }, + new String[]{ ImplHelper.CLASSNAME_JDO_OBJECT_ID_FIELD_SUPPLIER, + "Object" }, + null, + ImplHelper.getJDOCopyKeyFieldsToOid(oidClassName, + superOidClassName, + "ofs", + "oid", + keyFieldNames, + keyFieldTypes, + keyFieldNumbers), + ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_JDO_COPY_KEY_FIELDS_FROM_OID, + Modifier.PUBLIC, + "void", + new String[]{ "ofc", "oid" }, + new String[]{ ImplHelper.CLASSNAME_JDO_OBJECT_ID_FIELD_CONSUMER, + "Object" }, + null, + ImplHelper.getJDOCopyKeyFieldsFromOid(oidClassName, + superOidClassName, + "ofc", + "oid", + keyFieldNames, + keyFieldTypes, + keyFieldNumbers), + ImplHelper.COMMENT_ENHANCER_ADDED); + } + + private void writePCSerializationMembers(final String classname) + throws IOException + { + final long serialUID + = createJDOVersionUID(classname); + + //^olsen: to adapt + writer.writeField( + ImplHelper.FIELDNAME_SERIAL_VERSION_UID, + Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL, + "long", + ImplHelper.getSerialVersionUIDInitValue(serialUID), + new String[]{ "only a dummy value yet"}); + //ImplHelper.COMMENT_ENHANCER_ADDED); + + writer.writeMethod( + ImplHelper.METHODNAME_WRITE_OBJECT, + Modifier.PRIVATE, + "void", + new String[]{ "out" }, + new String[]{ ObjectOutputStream.class.getName() }, + new String[]{ IOException.class.getName() }, + ImplHelper.getWriteObjectImpl("out"), + ImplHelper.COMMENT_ENHANCER_ADDED); + } + + private void writeOidClass(final String classname, + final String oidClassName, + final boolean enclosedOid) + throws IOException + { + final int indent = (enclosedOid ? 1 : 0); + writer.writeComments(indent, new String[]{ + "----------------------------------------------------------------------", + "Key Class:", + "----------------------------------------------------------------------" + }); + writer.writeln(); + + writer.setInitialIndents(indent); + + final String superOidClassName + = NameHelper.normalizeClassName(meta.getSuperKeyClass(classname)); + + writer.writeClassHeader( + (enclosedOid ? Modifier.PUBLIC | Modifier.STATIC : 0), + oidClassName, + superOidClassName, + new String[]{ Serializable.class.getName() }, + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + + final boolean isPCRoot + = meta.isPersistenceCapableRootClass(classname); + + final String[] pknames = meta.getKeyFields(classname); + final String[] pktypes = meta.getFieldType(classname, pknames); + + // write the PK-fields + for (int i = 0; i < pknames.length; i++) { + writer.writeField( + pknames[i], + Modifier.PUBLIC, + pktypes[i], + null, + null); + } + + // write default constructor + writer.writeConstructor( + NameHelper.getClassName(oidClassName), + Modifier.PUBLIC, + null, null, null, + ImplHelper.getDefaultConstructorImpl(), + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + + // write string argument constructor + writer.writeConstructor( + NameHelper.getClassName(oidClassName), + Modifier.PUBLIC, + new String[]{ "str" }, + new String[]{ "String" }, + null, + ImplHelper.getOidStringArgConstructorImpl(superOidClassName, + "str"), + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + + // hashCode + writer.writeMethod( + "hashCode", + Modifier.PUBLIC, + "int", + null, + null, + null, + ImplHelper.getOidHashCodeImpl(pknames, + pktypes, + isPCRoot), + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + + // equals + writer.writeMethod( + "equals", Modifier.PUBLIC, "boolean", + new String[]{ "pk" }, + new String[]{ Object.class.getName() }, + null, + ImplHelper.getOidEqualsImpl(oidClassName, + pknames, + pktypes, + "pk", + isPCRoot), + ImplHelper.COMMENT_NOT_ENHANCER_ADDED); + + writer.writeClassEnd(); + writer.setInitialIndents(0); + } + + //^olsen to adapt + static private long createJDOVersionUID(final String classname) + { + return classname.hashCode(); + } + + static private String createMethodName(final String prefix, + final String fieldname) + { + return (prefix + Character.toUpperCase(fieldname.charAt(0)) + + fieldname.substring(1)); + } + + private void printMessage(String msg) + { + out.println(msg); + } + + private void printError(String msg, + Throwable ex) + { + if (msg != null) { + err.println(msg + (ex != null ? ": " + ex.getMessage() : "")); + } + if (ex != null) { + ex.printStackTrace(err); + } + } +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/NameHelper.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/NameHelper.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/NameHelper.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/generator/NameHelper.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,72 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed 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.jdo.impl.enhancer.generator; + + +/** + * Helps with class name conversions. + */ +class NameHelper +{ + static String normalizeClassName(String classname) + { + if (classname == null) { + return null; + } + return classname.replace('/', '.').replace('$', '.'); + } + +/* + static String convertClassName(String classname) + { + if (classname == null) { + return null; + } + return classname.replace('.', '_').replace('$', '_'); + } +*/ + + static String getPackageName(String classname) + { + if (classname == null) { + return null; + } + classname = classname.replace('/', '.'); + final int p = classname.lastIndexOf('.'); + return classname.substring(0, p > 0 ? p : 0); + } + + static String getEnclosedClassName(String classname) + { + if (classname == null) { + return null; + } + classname = classname.replace('/', '.'); + final int p = classname.lastIndexOf('.'); + return classname.substring(p + 1); + } + + static String getClassName(String classname) + { + if (classname == null) { + return null; + } + classname = normalizeClassName(classname); + final int p = classname.lastIndexOf('.'); + return classname.substring(p + 1); + } +}
