db-jdo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From m..@apache.org
Subject svn commit: r158176 [13/79] - in incubator/jdo/trunk/ri11: ./ src/ src/conf/ src/java/ src/java/org/ src/java/org/apache/ src/java/org/apache/jdo/ src/java/org/apache/jdo/ejb/ src/java/org/apache/jdo/enhancer/ src/java/org/apache/jdo/impl/ src/java/org/apache/jdo/impl/enhancer/ src/java/org/apache/jdo/impl/enhancer/classfile/ src/java/org/apache/jdo/impl/enhancer/core/ src/java/org/apache/jdo/impl/enhancer/generator/ src/java/org/apache/jdo/impl/enhancer/meta/ src/java/org/apache/jdo/impl/enhancer/meta/model/ src/java/org/apache/jdo/impl/enhancer/meta/prop/ src/java/org/apache/jdo/impl/enhancer/meta/util/ src/java/org/apache/jdo/impl/enhancer/util/ src/java/org/apache/jdo/impl/fostore/ src/java/org/apache/jdo/impl/jdoql/ src/java/org/apache/jdo/impl/jdoql/jdoqlc/ src/java/org/apache/jdo/impl/jdoql/scope/ src/java/org/apache/jdo/impl/jdoql/tree/ src/java/org/apache/jdo/impl/model/ src/java/org/apache/jdo/impl/model/java/ src/java/org/apache/jdo/impl/model/java/runtime/ src/java/org/apache/jdo/impl/model/jdo/ src/java/org/apache/jdo/impl/model/jdo/caching/ src/java/org/apache/jdo/impl/model/jdo/util/ src/java/org/apache/jdo/impl/model/jdo/xml/ src/java/org/apache/jdo/impl/pm/ src/java/org/apache/jdo/impl/sco/ src/java/org/apache/jdo/impl/state/ src/java/org/apache/jdo/jdoql/ src/java/org/apache/jdo/jdoql/tree/ src/java/org/apache/jdo/model/ src/java/org/apache/jdo/model/java/ src/java/org/apache/jdo/model/jdo/ src/java/org/apache/jdo/pm/ src/java/org/apache/jdo/sco/ src/java/org/apache/jdo/state/ src/java/org/apache/jdo/store/ src/java/org/apache/jdo/util/ test/ test/conf/ test/enhancer/ test/enhancer/sempdept/ test/enhancer/sempdept/src/ test/enhancer/sempdept/src/empdept/ test/fsuid2/ test/fsuid2/org/ test/fsuid2/org/apache/ test/fsuid2/org/apache/jdo/ test/fsuid2/org/apache/jdo/pc/ test/java/ test/java/org/ test/java/org/apache/ test/java/org/apache/jdo/ test/java/org/apache/jdo/impl/ test/java/org/apache/jdo/impl/fostore/ test/java/org/apache/jdo/pc/ test/java/org/apache/jdo/pc/appid/ test/java/org/apache/jdo/pc/empdept/ test/java/org/apache/jdo/pc/serializable/ test/java/org/apache/jdo/pc/xempdept/ test/java/org/apache/jdo/test/ test/java/org/apache/jdo/test/query/ test/java/org/apache/jdo/test/util/ test/jdo/ test/jdo/org/ test/jdo/org/apache/ test/jdo/org/apache/jdo/ test/jdo/org/apache/jdo/pc/ test/jdo/org/apache/jdo/pc/appid/ test/jdo/org/apache/jdo/pc/empdept/ test/jdo/org/apache/jdo/pc/serializable/ test/jdo/org/apache/jdo/pc/xempdept/ xdocs/
Date Sat, 19 Mar 2005 01:05:59 GMT
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);
+    } 
+}



Mime
View raw message