0001: /*
0002: * Copyright (c) 1998 - 2005 Versant Corporation
0003: * All rights reserved. This program and the accompanying materials
0004: * are made available under the terms of the Eclipse Public License v1.0
0005: * which accompanies this distribution, and is available at
0006: * http://www.eclipse.org/legal/epl-v10.html
0007: *
0008: * Contributors:
0009: * Versant Corporation - initial API and implementation
0010: */
0011: package com.versant.core.metadata.generator;
0012:
0013: import com.versant.core.metadata.*;
0014: import com.versant.core.common.*;
0015: import com.versant.core.compiler.ClassSpec;
0016: import com.versant.core.jdo.VersantPersistenceManagerImp;
0017: import com.versant.core.jdo.PCStateMan;
0018: import com.versant.core.jdo.VersantStateManager;
0019: import com.versant.core.server.OIDGraph;
0020: import com.versant.core.util.IntArray;
0021: import com.versant.core.util.OIDObjectOutput;
0022: import com.versant.core.util.OIDObjectInput;
0023:
0024: import javax.jdo.JDOFatalInternalException;
0025: import javax.jdo.spi.PersistenceCapable;
0026: import java.util.*;
0027: import java.math.BigDecimal;
0028: import java.io.*;
0029:
0030: /**
0031: * Generates java source for a State class for a PC class.
0032: */
0033: public abstract class StateSrcGenerator {
0034:
0035: protected ClassMetaData cmd;
0036: protected String className;
0037: protected ArrayList imutableTypeList;
0038: protected ArrayList nonObjectClassTypeList;
0039: protected ArrayList realNonObjectClassTypeList;
0040: protected HashMap getFieldToClass;
0041: protected HashMap classToSetField;
0042: protected HashMap classToGetFieldAbs;
0043: protected HashMap classToSetFieldAbs;
0044: protected HashMap classToInternalSetField;
0045: protected HashMap classToInternalSetFieldAbs;
0046: protected HashMap typeToResultSetGetField;
0047: protected HashMap typeToPreparedStatementSetField;
0048: protected HashMap wrapperTypesToPrimative;
0049: protected HashMap primativeTypesToWrapper;
0050: protected HashMap wrapperTypesToValue;
0051: protected HashMap wrapperStringToValue;
0052: protected HashMap primClassToSerReadMethod;
0053: protected HashMap primClassToSerWriteMethod;
0054:
0055: protected static final String CLASS_META_DATA_CLASS = ClassMetaData.class
0056: .getName();
0057: protected static final String FIELD_META_DATA_CLASS = FieldMetaData.class
0058: .getName();
0059: protected static final String OID_SUPER_CLASS = OID.class.getName();
0060: protected static final String STATE_SUPER_CLASS = State.class
0061: .getName();
0062: protected static final String INT_ARRAY = IntArray.class.getName();
0063:
0064: protected ClassSpec spec;
0065:
0066: //####################################################################################################
0067:
0068: protected final String FIELD_NOT_FOUND_EXCEPTION = "javax.jdo.JDOFatalInternalException";
0069: protected final String FILLED_FIELD_NAME = "filled";
0070: protected final String DIRTY_FIELD_NAME = "dirtyFields";
0071: protected final String RESOLVED_NAME = "resolved";
0072: public static final String JDBC_CONVERTER_FIELD_PREFIX = "jdbcConverter_";
0073: public static final String SCHEMA_FIELD_PREFIX = "schemaField_";
0074: public static final String VDS_FIELD_PREFIX = "vdsField_";
0075:
0076: protected int totalNoOfFields;
0077:
0078: public StateSrcGenerator() {
0079: typeToResultSetGetField = new HashMap();
0080: typeToResultSetGetField.put(int.class, "getInt");
0081: typeToResultSetGetField.put(byte.class, "getByte");
0082: typeToResultSetGetField.put(short.class, "getShort");
0083: typeToResultSetGetField.put(float.class, "getFloat");
0084: typeToResultSetGetField.put(double.class, "getDouble");
0085: typeToResultSetGetField.put(long.class, "getLong");
0086: typeToResultSetGetField.put(boolean.class, "getBoolean");
0087: typeToResultSetGetField.put(String.class, "getString");
0088: typeToResultSetGetField.put(byte[].class, "getBytes");
0089: typeToResultSetGetField.put(java.math.BigDecimal.class,
0090: "getBigDecimal"); // has a scale
0091: // typeToResultSetGetField.put(new ObjectType("java.sql.Date"), "getDate");
0092: // typeToResultSetGetField.put(new ObjectType("java.sql.Time"), "getTime");
0093: // typeToResultSetGetField.put(new ObjectType("java.sql.Timestamp"), "getTimestamp");
0094: // typeToResultSetGetField.put(new ObjectType("java.sql.InputStream"), "getAsciiStream");
0095: // typeToResultSetGetField.put(new ObjectType("java.sql.InputStream"), "getBinaryStream");
0096:
0097: typeToPreparedStatementSetField = new HashMap();
0098: typeToPreparedStatementSetField.put(int.class, "setInt");
0099: typeToPreparedStatementSetField.put(byte.class, "setByte");
0100: typeToPreparedStatementSetField.put(short.class, "setShort");
0101: typeToPreparedStatementSetField.put(float.class, "setFloat");
0102: typeToPreparedStatementSetField.put(double.class, "setDouble");
0103: typeToPreparedStatementSetField.put(long.class, "setLong");
0104: typeToPreparedStatementSetField
0105: .put(boolean.class, "setBoolean");
0106: typeToPreparedStatementSetField.put(String.class, "setString");
0107: typeToPreparedStatementSetField.put(Object.class, "setObject");
0108: typeToPreparedStatementSetField.put(byte[].class, "setBytes");
0109: typeToPreparedStatementSetField.put(BigDecimal.class,
0110: "setBigDecimal");
0111: // typeToPreparedStatementSetField.put(new ObjectType("java.sql.Date"), "setDate"); //
0112: // typeToPreparedStatementSetField.put(new ObjectType("java.sql.Time"), "setTime");
0113: // typeToPreparedStatementSetField.put(new ObjectType("java.sql.Timestamp"), "setTimestamp");
0114: // typeToPreparedStatementSetField.put(new ObjectType("java.sql.InputStream"), "setAsciiStream");
0115: // typeToPreparedStatementSetField.put(new ObjectType("java.sql.InputStream"), "setBinaryStream");
0116:
0117: getFieldToClass = new HashMap();
0118: getFieldToClass.put("getIntField", int.class);
0119: getFieldToClass.put("getByteField", byte.class);
0120: getFieldToClass.put("getCharField", char.class);
0121: getFieldToClass.put("getShortField", short.class);
0122: getFieldToClass.put("getFloatField", float.class);
0123: getFieldToClass.put("getDoubleField", double.class);
0124: getFieldToClass.put("getLongField", long.class);
0125: getFieldToClass.put("getLongFieldInternal", long.class);
0126: getFieldToClass.put("getBooleanField", boolean.class);
0127: getFieldToClass.put("getStringField", String.class);
0128:
0129: classToSetField = new HashMap();
0130: classToSetField.put(int.class, "setIntField");
0131: classToSetField.put(byte.class, "setByteField");
0132: classToSetField.put(long.class, "setLongField");
0133: classToSetField.put(char.class, "setCharField");
0134: classToSetField.put(short.class, "setShortField");
0135: classToSetField.put(float.class, "setFloatField");
0136: classToSetField.put(double.class, "setDoubleField");
0137: classToSetField.put(boolean.class, "setBooleanField");
0138: classToSetField.put(String.class, "setStringField");
0139:
0140: classToGetFieldAbs = new HashMap();
0141: classToGetFieldAbs.put(int.class, "getIntFieldAbs");
0142: classToGetFieldAbs.put(byte.class, "getByteFieldAbs");
0143: classToGetFieldAbs.put(char.class, "getCharFieldAbs");
0144: classToGetFieldAbs.put(short.class, "getShortFieldAbs");
0145: classToGetFieldAbs.put(float.class, "getFloatFieldAbs");
0146: classToGetFieldAbs.put(double.class, "getDoubleFieldAbs");
0147: classToGetFieldAbs.put(long.class, "getLongFieldAbs");
0148: classToGetFieldAbs.put(boolean.class, "getBooleanFieldAbs");
0149: classToGetFieldAbs.put(String.class, "getStringFieldAbs");
0150:
0151: classToSetFieldAbs = new HashMap();
0152: classToSetFieldAbs.put(int.class, "setIntFieldAbs");
0153: classToSetFieldAbs.put(byte.class, "setByteFieldAbs");
0154: classToSetFieldAbs.put(long.class, "setLongFieldAbs");
0155: classToSetFieldAbs.put(char.class, "setCharFieldAbs");
0156: classToSetFieldAbs.put(short.class, "setShortFieldAbs");
0157: classToSetFieldAbs.put(float.class, "setFloatFieldAbs");
0158: classToSetFieldAbs.put(double.class, "setDoubleFieldAbs");
0159: classToSetFieldAbs.put(boolean.class, "setBooleanFieldAbs");
0160: classToSetFieldAbs.put(String.class, "setStringFieldAbs");
0161:
0162: classToInternalSetField = new HashMap();
0163: classToInternalSetField.put(int.class, "setInternalIntField");
0164: classToInternalSetField.put(byte.class, "setInternalByteField");
0165: classToInternalSetField.put(long.class, "setInternalLongField");
0166: classToInternalSetField.put(char.class, "setInternalCharField");
0167: classToInternalSetField.put(short.class,
0168: "setInternalShortField");
0169: classToInternalSetField.put(float.class,
0170: "setInternalFloatField");
0171: classToInternalSetField.put(double.class,
0172: "setInternalDoubleField");
0173: classToInternalSetField.put(String.class,
0174: "setInternalStringField");
0175: classToInternalSetField.put(boolean.class,
0176: "setInternalBooleanField");
0177:
0178: classToInternalSetFieldAbs = new HashMap();
0179: classToInternalSetFieldAbs.put(int.class,
0180: "setInternalIntFieldAbs");
0181: classToInternalSetFieldAbs.put(byte.class,
0182: "setInternalByteFieldAbs");
0183: classToInternalSetFieldAbs.put(long.class,
0184: "setInternalLongFieldAbs");
0185: classToInternalSetFieldAbs.put(char.class,
0186: "setInternalCharFieldAbs");
0187: classToInternalSetFieldAbs.put(short.class,
0188: "setInternalShortFieldAbs");
0189: classToInternalSetFieldAbs.put(float.class,
0190: "setInternalFloatFieldAbs");
0191: classToInternalSetFieldAbs.put(double.class,
0192: "setInternalDoubleFieldAbs");
0193: classToInternalSetFieldAbs.put(String.class,
0194: "setInternalStringFieldAbs");
0195: classToInternalSetFieldAbs.put(boolean.class,
0196: "setInternalBooleanFieldAbs");
0197:
0198: wrapperTypesToPrimative = new HashMap(8);
0199: wrapperTypesToPrimative.put(Integer.class, Integer.TYPE);
0200: wrapperTypesToPrimative.put(Byte.class, Byte.TYPE);
0201: wrapperTypesToPrimative.put(Short.class, Short.TYPE);
0202: wrapperTypesToPrimative.put(Float.class, Float.TYPE);
0203: wrapperTypesToPrimative.put(Double.class, Double.TYPE);
0204: wrapperTypesToPrimative.put(Long.class, Long.TYPE);
0205: wrapperTypesToPrimative.put(Boolean.class, Boolean.TYPE);
0206: wrapperTypesToPrimative.put(Character.class, Character.TYPE);
0207:
0208: primativeTypesToWrapper = new HashMap(8);
0209: primativeTypesToWrapper.put(Integer.TYPE, "Integer");
0210: primativeTypesToWrapper.put(Byte.TYPE, "Byte");
0211: primativeTypesToWrapper.put(Character.TYPE, "Character");
0212: primativeTypesToWrapper.put(Short.TYPE, "Short");
0213: primativeTypesToWrapper.put(Float.TYPE, "Float");
0214: primativeTypesToWrapper.put(Double.TYPE, "Double");
0215: primativeTypesToWrapper.put(Long.TYPE, "Long");
0216: primativeTypesToWrapper.put(Boolean.TYPE, "Boolean");
0217:
0218: wrapperTypesToValue = new HashMap(8);
0219: wrapperTypesToValue.put(Integer.class, "intValue");
0220: wrapperTypesToValue.put(Byte.class, "byteValue");
0221: wrapperTypesToValue.put(Character.class, "charValue");
0222: wrapperTypesToValue.put(Short.class, "shortValue");
0223: wrapperTypesToValue.put(Float.class, "floatValue");
0224: wrapperTypesToValue.put(Double.class, "doubleValue");
0225: wrapperTypesToValue.put(Long.class, "longValue");
0226: wrapperTypesToValue.put(Boolean.class, "booleanValue");
0227:
0228: wrapperStringToValue = new HashMap(8);
0229: wrapperStringToValue.put("Integer", "intValue");
0230: wrapperStringToValue.put("Byte", "byteValue");
0231: wrapperStringToValue.put("Character", "charValue");
0232: wrapperStringToValue.put("Short", "shortValue");
0233: wrapperStringToValue.put("Float", "floatValue");
0234: wrapperStringToValue.put("Double", "doubleValue");
0235: wrapperStringToValue.put("Long", "longValue");
0236: wrapperStringToValue.put("Boolean", "booleanValue");
0237:
0238: nonObjectClassTypeList = new ArrayList();
0239: nonObjectClassTypeList.add(int.class);
0240: nonObjectClassTypeList.add(byte.class);
0241: nonObjectClassTypeList.add(long.class);
0242: nonObjectClassTypeList.add(char.class);
0243: nonObjectClassTypeList.add(short.class);
0244: nonObjectClassTypeList.add(float.class);
0245: nonObjectClassTypeList.add(double.class);
0246: nonObjectClassTypeList.add(boolean.class);
0247: nonObjectClassTypeList.add(String.class);
0248:
0249: realNonObjectClassTypeList = new ArrayList();
0250: realNonObjectClassTypeList.add(int.class);
0251: realNonObjectClassTypeList.add(byte.class);
0252: realNonObjectClassTypeList.add(long.class);
0253: realNonObjectClassTypeList.add(char.class);
0254: realNonObjectClassTypeList.add(short.class);
0255: realNonObjectClassTypeList.add(float.class);
0256: realNonObjectClassTypeList.add(double.class);
0257: realNonObjectClassTypeList.add(boolean.class);
0258:
0259: primClassToSerReadMethod = new HashMap(8);
0260: primClassToSerReadMethod.put(int.class, "readInt");
0261: primClassToSerReadMethod.put(byte.class, "readByte");
0262: primClassToSerReadMethod.put(char.class, "readChar");
0263: primClassToSerReadMethod.put(short.class, "readShort");
0264: primClassToSerReadMethod.put(float.class, "readFloat");
0265: primClassToSerReadMethod.put(double.class, "readDouble");
0266: primClassToSerReadMethod.put(long.class, "readLong");
0267: primClassToSerReadMethod.put(boolean.class, "readBoolean");
0268:
0269: primClassToSerWriteMethod = new HashMap(8);
0270: primClassToSerWriteMethod.put(int.class, "writeInt");
0271: primClassToSerWriteMethod.put(byte.class, "writeByte");
0272: primClassToSerWriteMethod.put(char.class, "writeChar");
0273: primClassToSerWriteMethod.put(short.class, "writeShort");
0274: primClassToSerWriteMethod.put(float.class, "writeFloat");
0275: primClassToSerWriteMethod.put(double.class, "writeDouble");
0276: primClassToSerWriteMethod.put(long.class, "writeLong");
0277: primClassToSerWriteMethod.put(boolean.class, "writeBoolean");
0278:
0279: imutableTypeList = new ArrayList();
0280: imutableTypeList.add(java.util.Locale.class);
0281: imutableTypeList.add(java.math.BigDecimal.class);
0282: imutableTypeList.add(java.math.BigInteger.class);
0283: imutableTypeList.add(Integer.class);
0284: imutableTypeList.add(Byte.class);
0285: imutableTypeList.add(Character.class);
0286: imutableTypeList.add(Short.class);
0287: imutableTypeList.add(Float.class);
0288: imutableTypeList.add(Double.class);
0289: imutableTypeList.add(Long.class);
0290: imutableTypeList.add(Boolean.class);
0291: imutableTypeList.add(String.class);
0292:
0293: }
0294:
0295: /**
0296: * Generates a class State object from the classInfo object.
0297: */
0298: public ClassSpec generateState(ClassMetaData cmd) {
0299:
0300: this .cmd = cmd;
0301: this .className = cmd.stateClassName;
0302: this .totalNoOfFields = cmd.stateFields.length;
0303: spec = new ClassSpec(null, className, State.class.getName());
0304:
0305: spec.addImportsForJavaLang();
0306: spec.addImport(OID.class.getName());
0307: spec.addImport(State.class.getName());
0308: spec.addImport(ClassMetaData.class.getName());
0309: spec.addImport(FieldMetaData.class.getName());
0310: spec.addImport(ModelMetaData.class.getName());
0311: spec.addImport(ObjectOutput.class.getName());
0312: spec.addImport(ObjectInput.class.getName());
0313: spec.addImport(DataInputStream.class.getName());
0314: spec.addImport(DataOutputStream.class.getName());
0315: spec.addImport(IOException.class.getName());
0316: spec.addImport(JDOFatalInternalException.class.getName());
0317: spec.addImport(VersantPersistenceManagerImp.class.getName());
0318: spec.addImport(PersistenceCapable.class.getName());
0319: spec.addImport(FetchGroup.class.getName());
0320: spec.addImport(OIDGraph.class.getName());
0321: spec.addImport(StateUtil.class.getName());
0322: spec.addImport(PCStateMan.class.getName());
0323: spec.addImport(SerUtils.class.getName());
0324: spec.addImport(OIDObjectOutput.class.getName());
0325: spec.addImport(OIDObjectInput.class.getName());
0326: spec.addImport(Utils.class.getName());
0327: spec.addImport(PersistenceContext.class.getName());
0328: spec.addImport(VersantStateManager.class.getName());
0329:
0330: addFields();
0331: addInitStatics();
0332:
0333: addConstructor(); //cool
0334: addSetClassMetaData(); //cool
0335: addNewInstance(); //cool
0336:
0337: addAllGetXXXFields(); //cool
0338: addAllSetInternalXXXFields(); //cool
0339: addAllSetXXXFields(); //cool
0340: addAllGetXXXFieldsAbs(); //cool
0341: addAllSetInternalXXXFieldsAbs();//cool
0342: addAllSetXXXFieldsAbs(); //cool
0343: addHasSameFields(); //cool
0344: addCopyFields(); //cool
0345: addClear(); //cool
0346: addMakeDirty(); //cool
0347: addSetFilled();
0348: addIsDirtyInt(); //cool
0349: addGetClassIndex(); //cool
0350: addHashCode(); //cool
0351: addEqualsObject(); //cool
0352: addContainsField(); //cool
0353: addMakeClean(); //cool
0354: addClearNonFilled(); //cool
0355: addUpdateNonFilled(); //cool
0356: addGetCopy(); //cool
0357: addGetFieldNos(); //cool
0358: addContainsApplicationIdentityFields(); //cool
0359: addGetInternalObjectField(); //cool
0360: addGetInternalObjectFieldAbs(); //cool
0361: addIsNull(); //cool
0362: addHasSameNullFields(); //cool
0363: addFindDirectEdges(); //cool
0364: addReplaceNewObjectOIDs(); //cool
0365: addIsDirty(); //cool
0366: addIsHollow(); //cool
0367: addUpdateFrom(); //cool
0368: addGetPass1FieldNos(); //cool
0369: addGetPass2FieldNos(); //cool
0370: addContainsPass1Fields(); //cool
0371: addGetPass1FieldRefFieldNosWithNewOids();
0372: addContainsPass2Fields(); //cool
0373: addIsEmpty(); //cool
0374: addContainFields(); //cool
0375: addGetClassMetaData(); //cool
0376: addGetClassMetaDataJMD(); //cool
0377: addCompareToPass1(); //cool
0378: addClearTransactionNonPersistentFields(); //cool
0379: addToString(); //cool
0380: addClearCollectionFields(); //cool
0381: addContainsFetchGroup(); //cool
0382: addReplaceSCOFields(); //cool
0383: addClearApplicationIdentityFields();
0384: addCopyKeyFieldsFromOID();
0385: addCheckKeyFields();
0386: addCopyKeyFieldsUpdate();
0387: addClearSCOFields();
0388: addGetNullFields();
0389: addContainsFieldAbs();
0390: addMakeDirtyAbs();
0391: addContainFieldsAbs();
0392: addGetResolvableObjectFieldAbs();
0393: addClearNonAutoSetFields();
0394: addUpdateAutoSetFieldsCreated();
0395: addUpdateAutoSetFieldsModified();
0396: addGetResolvableObjectField(); //cool
0397: addAddRefs(); //cool
0398: addWriteExternal();
0399: addReadExternal();
0400:
0401: addCopyOptimisticLockingField();
0402: addCopyFieldsForOptimisticLocking();
0403: addGetDirtyState(); //cool
0404: addRetrieve();
0405: addClearDirtyFields();
0406: addPrepare(); //cool
0407: addContainsValidAppIdFields();
0408: addUnmanageSCOFields();
0409: addVersion();
0410: addIsResolvedForClient();
0411: addGetOptimisticLockingValue();
0412: addOneToManyInverseFieldsForL2Evict();
0413:
0414: addClearFilledFlags();
0415: addFillForRead();
0416: addIsFieldNullorZero();
0417:
0418: return spec;
0419: }
0420:
0421: /**
0422: * Add method to fill in values of static fields from ModelMetaData.
0423: * This is invoked once the class has been loaded.
0424: */
0425: protected void addInitStatics() {
0426: StringBuffer buf = new StringBuffer();
0427: buf
0428: .append("\tpublic static boolean initStatics(ModelMetaData jmd) {\n");
0429: addInitStaticsBody(buf);
0430: buf.append("\t\treturn true;\n");
0431: buf.append("\t}");
0432: spec.addMethod(buf.toString());
0433: }
0434:
0435: protected void addInitStaticsBody(StringBuffer buf) {
0436: buf.append("\t\tif (cmd != null) return false;\n");
0437: buf.append("\t\tcmd = jmd.classes[" + cmd.index + "];\n");
0438: }
0439:
0440: protected void addOneToManyInverseFieldsForL2Evict() {
0441: // public final void addOneToManyInverseFieldsForL2Evict(VersantPersistenceManagerImp pm) {
0442: // if (_4 != null) {
0443: // pm.evictFromL2CacheAfterCommitImp(_4);
0444: // }
0445: // }
0446:
0447: StringBuffer buf = new StringBuffer();
0448: buf
0449: .append("\n\tpublic final void addOneToManyInverseFieldsForL2Evict(VersantPersistenceManagerImp pm) {\n");
0450: int num = cmd.stateFields.length;
0451: for (int i = 0; i < num; i++) {
0452: FieldMetaData fmd = cmd.stateFields[i];
0453: if (fmd.isDetail && !fmd.managed) {
0454: int fieldNo = fmd.stateFieldNo;
0455: buf.append("\t\tif (_" + fieldNo + " != null) {\n");
0456: buf.append("\t\t\tpm.evictFromL2CacheAfterCommitImp(_"
0457: + fieldNo + ");\n");
0458: buf.append("\t\t}\n");
0459: }
0460: }
0461: buf.append("\t}\n");
0462: spec.addMethod(buf.toString());
0463: }
0464:
0465: protected void addFillForRead() {
0466: StringBuffer buf = new StringBuffer();
0467: // public final void fillForRead(State dest, VersantPersistenceManagerImp pm) {
0468: // HYPERDRIVE_STATE_com_versant_core_jdo_junit_test1_model_ObjectFieldWithPCValue state = (HYPERDRIVE_STATE_com_versant_core_jdo_junit_test1_model_ObjectFieldWithPCValue)dest;
0469: // PersistenceCapable pc = null;
0470: // if (_0 instanceof PersistenceCapable) {
0471: // pc = (PersistenceCapable)_0;
0472: // if (pc.jdoGetPersistenceManager() != null) {
0473: // state._0 = StateUtil.getPValueForRef(pc, pm);
0474: // }
0475: // } else {
0476: // state._0 = _0;
0477: // }
0478: // state._1 = _1;
0479: // state.filled0 |= 3;
0480: // }
0481:
0482: buf
0483: .append("\n\tpublic final void fillForRead(State dest, VersantPersistenceManagerImp pm) {\n");
0484: if (cmd.storeAllFields) {
0485: buf.append("\t\t" + className + " state = (" + className
0486: + ")dest;\n");
0487:
0488: boolean haveOID = false;
0489: int num = cmd.stateFields.length;
0490: for (int i = 0; i < num; i++) {
0491: FieldMetaData fmd = cmd.stateFields[i];
0492: if (fmd.category == MDStatics.CATEGORY_REF
0493: || fmd.category == MDStatics.CATEGORY_POLYREF) {
0494: haveOID = true;
0495: }
0496: }
0497: if (haveOID) {
0498: buf.append("\t\tPersistenceCapable pc = null;\n");
0499: }
0500: for (int i = 0; i < num; i++) {
0501: FieldMetaData fmd = cmd.stateFields[i];
0502: int fieldNum = fmd.stateFieldNo;
0503: if (fmd.fake) {
0504: buf.append("\t\tstate._" + fieldNum + " = _"
0505: + fieldNum + ";\n");
0506: } else {
0507: int cat = fmd.category;
0508: if (cat == MDStatics.CATEGORY_REF
0509: || cat == MDStatics.CATEGORY_POLYREF) {
0510: buf
0511: .append("\t\tif (_"
0512: + fieldNum
0513: + " instanceof PersistenceCapable) {\n");
0514: buf.append("\t\t\tpc = (PersistenceCapable)_"
0515: + fieldNum + ";\n");
0516: buf
0517: .append("\t\t\tif (pc.jdoGetPersistenceManager() != null) {\n");
0518: buf
0519: .append("\t\t\t\tstate._"
0520: + fieldNum
0521: + " = StateUtil.getPValueForRef(pc, pm);\n");
0522: buf.append("\t\t\t}\n");
0523: buf.append("\t\t} else {\n");
0524: buf.append("\t\t\tstate._" + fieldNum + " = _"
0525: + fieldNum + ";\n");
0526: buf.append("\t\t}\n");
0527: }
0528: }
0529: }
0530: boolean doMask = false;
0531: int[] masks = new int[getNumOfControlFields()];
0532: for (int i = 0; i < num; i++) {
0533:
0534: if (cmd.stateFields[i].fake
0535: || cmd.stateFields[i].category == MDStatics.CATEGORY_REF
0536: || cmd.stateFields[i].category == MDStatics.CATEGORY_POLYREF) {
0537: int fieldNum = cmd.stateFields[i].stateFieldNo;
0538: doMask = true;
0539: masks[getLocalVarIndex(0, fieldNum)] += getFieldIndex(fieldNum);
0540: }
0541: }
0542: if (doMask) {
0543: for (int i = 0; i < masks.length; i++) {
0544: if (masks[i] != 0) {
0545: buf.append("\t\tstate.filled" + i + " |= "
0546: + masks[i] + ";\n");
0547: }
0548: }
0549: }
0550: }
0551: buf.append("\t}\n");
0552: spec.addMethod(buf.toString());
0553: }
0554:
0555: protected void addGetOptimisticLockingValue() {
0556: StringBuffer buf = new StringBuffer();
0557: // public final Object getOptimisticLockingValue() {
0558: // return new Short(_23);
0559: // }
0560: buf
0561: .append("\n\tpublic final Object getOptimisticLockingValue() {\n");
0562: if (cmd.optimisticLockingField != null) {
0563: FieldMetaData fmd = cmd.optimisticLockingField;
0564: switch (fmd.typeCode) {
0565: case MDStatics.DATE:
0566: buf.append("\t\treturn _" + fmd.stateFieldNo + ";\n");
0567: break;
0568: case MDStatics.LONG:
0569: buf.append("\t\treturn new Long(_" + fmd.stateFieldNo
0570: + ");\n");
0571: break;
0572: case MDStatics.INT:
0573: buf.append("\t\treturn new Integer(_"
0574: + fmd.stateFieldNo + ");\n");
0575: break;
0576: case MDStatics.SHORT:
0577: buf.append("\t\treturn new Short(_" + fmd.stateFieldNo
0578: + ");\n");
0579: break;
0580: case MDStatics.BYTE:
0581: buf.append("\t\treturn new Byte(_" + fmd.stateFieldNo
0582: + ");\n");
0583: break;
0584: default:
0585: throw BindingSupportImpl.getInstance().internal(
0586: "Invalid typeCode " + fmd.typeCode
0587: + " for version field: stateFieldNo "
0588: + fmd.stateFieldNo + " " + fmd.name);
0589: }
0590: } else {
0591: buf.append("\t\treturn null;\n");
0592: }
0593: buf.append("\t}\n");
0594: spec.addMethod(buf.toString());
0595: }
0596:
0597: protected void addVersion() {
0598: StringBuffer buf = new StringBuffer();
0599: // public final String getVersion() {
0600: // return "3.2.0";
0601: // }
0602: buf.append("\n\tpublic final String getVersion() {\n");
0603: buf.append("\t\treturn \"" + Debug.VERSION + "\";\n");
0604: buf.append("\t}\n");
0605: spec.addMethod(buf.toString());
0606: }
0607:
0608: protected void addClearDirtyFields() {
0609: StringBuffer buf = new StringBuffer();
0610: // public final void clearDirtyFields() {
0611: // filled0 &= ~dirtyFields0;
0612: // resolved0 &= ~dirtyFields0;
0613: // dirtyFields0 = 0;
0614: //
0615: // filled1 &= ~dirtyFields1;
0616: // resolved1 &= ~dirtyFields1;
0617: // dirtyFields1 = 0;
0618: //
0619: // filled2 &= ~dirtyFields2;
0620: // resolved2 &= ~dirtyFields2;
0621: // dirtyFields2 = 0;
0622: // }
0623: buf.append("\n\tpublic final void clearDirtyFields() {\n");
0624: int num = getNumOfControlFields();
0625: for (int i = 0; i < num; i++) {
0626: buf.append("\t\tfilled" + i + " &= ~dirtyFields" + i
0627: + ";\n");
0628: buf.append("\t\tresolved" + i + " &= ~dirtyFields" + i
0629: + ";\n");
0630: buf.append("\t\tdirtyFields" + i + " = 0;\n");
0631: }
0632: buf.append("\t}\n");
0633: spec.addMethod(buf.toString());
0634: }
0635:
0636: protected void addUpdateAutoSetFieldsCreated() {
0637: StringBuffer buf = new StringBuffer();
0638: // public final void updateAutoSetFieldsCreated(Date now) {
0639: // _6 = 1;
0640: // filled0 |= 64;
0641: // }
0642: buf
0643: .append("\n\tpublic final void updateAutoSetFieldsCreated(java.util.Date now) {\n");
0644: if (cmd.hasAutoSetFields) {
0645: FieldMetaData[] stateFields = cmd.stateFields;
0646: for (int fieldNo = stateFields.length - 1; fieldNo >= 0; fieldNo--) {
0647: FieldMetaData fmd = cmd.stateFields[fieldNo];
0648: int autoset = fmd.autoSet;
0649: if (autoset != MDStatics.AUTOSET_CREATED
0650: && autoset != MDStatics.AUTOSET_BOTH) {
0651: continue;
0652: }
0653: switch (fmd.typeCode) {
0654: case MDStatics.DATE:
0655: buf.append("\t\t_" + fieldNo + " = now;\n");
0656: buf.append("\t\t" + getFilledFieldName(fieldNo)
0657: + " |= " + getFieldIndex(fieldNo) + ";\n");
0658:
0659: break;
0660: case MDStatics.INT:
0661: case MDStatics.SHORT:
0662: case MDStatics.BYTE:
0663: buf.append("\t\t_" + fieldNo + " = 1;\n");
0664: buf.append("\t\t" + getFilledFieldName(fieldNo)
0665: + " |= " + getFieldIndex(fieldNo) + ";\n");
0666: break;
0667: default:
0668: throw BindingSupportImpl
0669: .getInstance()
0670: .internal(
0671: "Invalid typeCode "
0672: + fmd.typeCode
0673: + " for autoset field: stateFieldNo "
0674: + fieldNo + " " + fmd.name);
0675: }
0676: }
0677: }
0678: buf.append("\t}\n");
0679: spec.addMethod(buf.toString());
0680: }
0681:
0682: protected void addUpdateAutoSetFieldsModified() {
0683: StringBuffer buf = new StringBuffer();
0684: // public final void updateAutoSetFieldsModified(Date now, State oldState) {
0685: // _6 = (short) (oldState.getShortField(6) + 1 & 32767);
0686: // filled0 |= 64;
0687: // }
0688: buf
0689: .append("\n\tpublic final void updateAutoSetFieldsModified(java.util.Date now, State oldState) {\n");
0690: if (cmd.hasAutoSetFields) {
0691: FieldMetaData[] stateFields = cmd.stateFields;
0692: for (int fieldNo = stateFields.length - 1; fieldNo >= 0; fieldNo--) {
0693: FieldMetaData fmd = cmd.stateFields[fieldNo];
0694: int autoset = fmd.autoSet;
0695: if (autoset != MDStatics.AUTOSET_MODIFIED
0696: && autoset != MDStatics.AUTOSET_BOTH) {
0697: continue;
0698: }
0699: switch (fmd.typeCode) {
0700: case MDStatics.DATE:
0701: buf.append("\t\t_" + fieldNo + " = now;\n");
0702: buf.append("\t\t" + getFilledFieldName(fieldNo)
0703: + " |= " + getFieldIndex(fieldNo) + ";\n");
0704: break;
0705: case MDStatics.INT:
0706: buf.append("\t\t_" + fieldNo
0707: + " = (oldState.getIntField(" + fieldNo
0708: + ") + 1 & " + 0x7FFFFFFF + ");\n");
0709: buf.append("\t\t" + getFilledFieldName(fieldNo)
0710: + " |= " + getFieldIndex(fieldNo) + ";\n");
0711: break;
0712: case MDStatics.SHORT:
0713: buf.append("\t\t_" + fieldNo
0714: + " = (short) (oldState.getShortField("
0715: + fieldNo + ") + 1 & " + 0x7FFF + ");\n");
0716: buf.append("\t\t" + getFilledFieldName(fieldNo)
0717: + " |= " + getFieldIndex(fieldNo) + ";\n");
0718: break;
0719: case MDStatics.BYTE:
0720: buf.append("\t\t_" + fieldNo
0721: + " = (byte) (oldState.getByteField("
0722: + fieldNo + ") + 1 & " + 0x7F + ");\n");
0723: buf.append("\t\t" + getFilledFieldName(fieldNo)
0724: + " |= " + getFieldIndex(fieldNo) + ";\n");
0725: break;
0726: default:
0727: throw BindingSupportImpl
0728: .getInstance()
0729: .internal(
0730: "Invalid typeCode "
0731: + fmd.typeCode
0732: + " for autoset field: stateFieldNo "
0733: + fieldNo + " " + fmd.name);
0734: }
0735: }
0736: }
0737: buf.append("\t}\n");
0738: spec.addMethod(buf.toString());
0739: }
0740:
0741: protected void addClearNonAutoSetFields() {
0742: StringBuffer buf = new StringBuffer();
0743: // public final void clearNonAutoSetFields() {
0744: // filled0 = filled0 & -64;
0745: // resolved0 = resolved0 & -64;
0746: // _2 = null;
0747: // _3 = null;
0748: // _4 = null;
0749: // _5 = null;
0750: // }
0751: buf.append("\n\tpublic final void clearNonAutoSetFields() {\n");
0752: int[] masks = new int[getNumOfControlFields()];
0753: int num = cmd.nonAutoSetStateFieldNos.length;
0754: for (int i = 0; i < num; i++) {
0755: int fieldNum = cmd.nonAutoSetStateFieldNos[i];
0756: masks[getLocalVarIndex(0, fieldNum)] += getFieldIndex(fieldNum);
0757: }
0758: int maskLenght = masks.length;
0759: for (int i = 0; i < maskLenght; i++) {
0760: if (masks[i] != 0) {
0761: buf.append("\t\tfilled" + i + " = filled" + i + " & "
0762: + (masks[i] ^ 0xFFFFFFFF) + ";\n");
0763: buf.append("\t\tresolved" + i + " = resolved" + i
0764: + " & " + (masks[i] ^ 0xFFFFFFFF) + ";\n");
0765: }
0766: }
0767: for (int i = 0; i < num; i++) {
0768: int fieldNum = cmd.nonAutoSetStateFieldNos[i];
0769: FieldMetaData data = cmd.stateFields[fieldNum];
0770: if (data.type.isPrimitive()) {
0771: continue;
0772: }
0773: buf.append("\t\t_" + fieldNum + " = null;\n");
0774: }
0775: buf.append("\t}\n");
0776: spec.addMethod(buf.toString());
0777: }
0778:
0779: protected void addMakeDirtyAbs() {
0780: StringBuffer buf = new StringBuffer();
0781: // public final void makeDirtyAbs(int absFieldNo) {
0782: // makeDirty(cmd.absToRel[absFieldNo]);
0783: // }
0784: buf
0785: .append("\n\tpublic final void makeDirtyAbs(int absFieldNo) {\n");
0786: buf.append("\t\tmakeDirty(cmd.absToRel[absFieldNo]);\n");
0787: buf.append("\t}\n");
0788: spec.addMethod(buf.toString());
0789: }
0790:
0791: protected void addContainsFieldAbs() {
0792: StringBuffer buf = new StringBuffer();
0793: // public final boolean containsFieldAbs(int absFieldNo) {
0794: // return containsField(cmd.absToRel[absFieldNo]);
0795: // }
0796: buf
0797: .append("\n\tpublic final boolean containsFieldAbs(int absFieldNo) {\n");
0798: buf
0799: .append("\t\treturn containsField(cmd.absToRel[absFieldNo]);\n");
0800: buf.append("\t}\n");
0801: spec.addMethod(buf.toString());
0802: }
0803:
0804: protected void addGetNullFields() {
0805: StringBuffer buf = new StringBuffer();
0806:
0807: // protected final int getNullFields(int index) {
0808: // int filled = 0;
0809: // int nullFields = 0;
0810: // switch (index) {
0811: // case 0: // '\0'
0812: // filled = filled0;
0813: // if ((filled & 4) != 0 && _2 == null) {
0814: // nullFields |= 4;
0815: // }
0816: // if ((filled & 8) != 0 && _3 == null) {
0817: // nullFields |= 8;
0818: // }
0819: // if ((filled & 16) != 0 && _4 == null) {
0820: // nullFields |= 16;
0821: // }
0822: // if ((filled & 32) != 0 && _5 == null) {
0823: // nullFields |= 32;
0824: // }
0825: // return nullFields;
0826: // }
0827: // return nullFields;
0828: // }
0829:
0830: buf
0831: .append("\n\tprivate final int getNullFields(int index) {\n");
0832: buf.append("\t\tint filled = 0;\n");
0833: buf.append("\t\tint nullFields = 0;\n");
0834: buf.append("\t\tswitch (index) {\n");
0835: int switchCount = getNumOfControlFields();
0836: for (int i = 0; i < switchCount; i++) {
0837: buf.append("\t\t\tcase " + i + ":\n");
0838: buf.append("\t\t\t\tfilled = filled" + i + ";\n");
0839: List objectList = getRealObjectFields(i);
0840: for (Iterator iter = objectList.iterator(); iter.hasNext();) {
0841: FieldMetaData data = (FieldMetaData) iter.next();
0842: int fieldNo = data.stateFieldNo;
0843: buf.append("\t\t\t\tif ((filled & "
0844: + getFieldIndex(fieldNo) + ") != 0 && _"
0845: + fieldNo + " == null) {\n");
0846: buf.append("\t\t\t\t\tnullFields |= "
0847: + getFieldIndex(fieldNo) + ";\n");
0848: buf.append("\t\t\t\t}\n");
0849: }
0850: buf.append("\t\t\t\treturn nullFields;\n");
0851: }
0852: buf.append("\t\t}\n");
0853: buf.append("\t\treturn nullFields;\n");
0854: buf.append("\t}\n");
0855: spec.addMethod(buf.toString());
0856: }
0857:
0858: protected void addClearSCOFields() {
0859: StringBuffer buf = new StringBuffer();
0860: // public final void clearSCOFields() {
0861: // filled0 = filled0 & -907301;
0862: // resolved0 = resolved0 & -907301;
0863: // _2 = null;
0864: // _5 = null;
0865: // _11 = null;
0866: // _12 = null;
0867: // _14 = null;
0868: // _15 = null;
0869: // _16 = null;
0870: // _18 = null;
0871: // _19 = null;
0872: // }
0873: buf.append("\n\tpublic final void clearSCOFields() {\n");
0874: int[] masks = new int[getNumOfControlFields()];
0875: int num = cmd.scoFieldNos.length;
0876: for (int i = 0; i < num; i++) {
0877: int fieldNum = cmd.scoFieldNos[i];
0878: masks[getLocalVarIndex(0, fieldNum)] += getFieldIndex(fieldNum);
0879: }
0880: int maskLenght = masks.length;
0881: for (int i = 0; i < maskLenght; i++) {
0882: if (masks[i] != 0) {
0883: buf.append("\t\tfilled" + i + " = filled" + i + " & "
0884: + (masks[i] ^ 0xFFFFFFFF) + ";\n");
0885: buf.append("\t\tresolved" + i + " = resolved" + i
0886: + " & " + (masks[i] ^ 0xFFFFFFFF) + ";\n");
0887: }
0888: }
0889: for (int i = 0; i < num; i++) {
0890: int fieldNum = cmd.scoFieldNos[i];
0891: buf.append("\t\t_" + fieldNum + " = null;\n");
0892: }
0893: buf.append("\t}\n");
0894: spec.addMethod(buf.toString());
0895: }
0896:
0897: protected void addCopyKeyFieldsUpdate() {
0898: StringBuffer buf = new StringBuffer();
0899: buf
0900: .append("\n\tpublic final void copyKeyFieldsUpdate(OID oid) {\n");
0901: buf.append("\t}\n");
0902: spec.addMethod(buf.toString());
0903: }
0904:
0905: protected void addCopyKeyFieldsFromOID() {
0906: StringBuffer buf = new StringBuffer();
0907: buf.append("\n\tpublic final void copyKeyFields(OID oid) {\n");
0908: buf.append("\t}\n");
0909: spec.addMethod(buf.toString());
0910: }
0911:
0912: protected void addCheckKeyFields() {
0913: StringBuffer buf = new StringBuffer();
0914: buf
0915: .append("\n\tpublic final boolean checkKeyFields(OID oid) {\n");
0916: buf.append("\t\treturn true;\n");
0917: buf.append("\t}\n");
0918: spec.addMethod(buf.toString());
0919:
0920: }
0921:
0922: protected void addClearApplicationIdentityFields() {
0923: StringBuffer buf = new StringBuffer();
0924: buf
0925: .append("\n\tpublic final void clearApplicationIdentityFields() {\n");
0926: buf.append("\t}\n");
0927: spec.addMethod(buf.toString());
0928: }
0929:
0930: protected boolean isDate(int fieldNo) {
0931: FieldMetaData info = cmd.stateFields[fieldNo];
0932: if (info.type.isAssignableFrom(Date.class)) {
0933: return true;
0934: }
0935: return false;
0936: }
0937:
0938: protected boolean isDate(FieldMetaData fmd) {
0939: if (fmd.type.isAssignableFrom(Date.class)) {
0940: return true;
0941: }
0942: return false;
0943: }
0944:
0945: protected void addReplaceSCOFields() {
0946: StringBuffer buf = new StringBuffer();
0947: // public final int replaceSCOFields(PersistenceCapable owner, VersantPersistenceManagerImp sm, int absFields[]) {
0948: // int count = 0;
0949: // if (_2 != null) {
0950: // _2 = (Date)cmd.stateFields[2].createSCO(sm, sm.getInternalSM(owner), cmd.stateFields[2], owner, _2);
0951: // absFields[count++] = cmd.stateFields[2].managedFieldNo;
0952: // }
0953: // if (_5 != null) {
0954: // _5 = (Date)cmd.stateFields[5].createSCO(sm, sm.getInternalSM(owner), cmd.stateFields[5], owner, _5);
0955: // absFields[count++] = cmd.stateFields[5].managedFieldNo;
0956: // }
0957: // return count;
0958: // }
0959:
0960: buf
0961: .append("\n\tpublic final int replaceSCOFields(PersistenceCapable owner, VersantPersistenceManagerImp sm, int absFields[]) {\n");
0962: buf.append("\t\tint count = 0;\n");
0963: int numSCO = cmd.scoFieldNos.length;
0964: if (numSCO > 0) {
0965: for (int i = 0; i < numSCO; i++) {
0966: int fieldNo = cmd.scoFieldNos[i];
0967: boolean isDate = isDate(fieldNo);
0968: buf.append("\t\tif (_" + fieldNo + " != null) {\n");
0969: buf
0970: .append("\t\t\t_"
0971: + fieldNo
0972: + " = "
0973: + (isDate ? "(java.util.Date)" : "")
0974: + "cmd.stateFields["
0975: + fieldNo
0976: + "].createSCO(sm, sm.getInternalSM(owner), cmd.stateFields["
0977: + fieldNo + "], owner, _" + fieldNo
0978: + ");\n");
0979: buf
0980: .append("\t\t\tabsFields[count++] = cmd.stateFields["
0981: + fieldNo + "].managedFieldNo;\n");
0982: buf.append("\t\t}\n");
0983: }
0984: }
0985: buf.append("\t\treturn count;\n");
0986: buf.append("\t}\n");
0987: spec.addMethod(buf.toString());
0988: }
0989:
0990: protected void addUnmanageSCOFields() {
0991: StringBuffer buf = new StringBuffer();
0992: // public final void unmanageSCOFields() {
0993: // if (_2 instanceof VersantSimpleSCO) {
0994: // ((VersantSimpleSCO) _2).makeTransient();
0995: // }
0996: // if (_5 instanceof VersantSimpleSCO) {
0997: // ((VersantSimpleSCO) _5).makeTransient();
0998: // }
0999: // }
1000: buf.append("\n\tpublic final void unmanageSCOFields() {\n");
1001: int numSCO = cmd.scoFieldNos.length;
1002: if (numSCO > 0) {
1003: for (int i = 0; i < numSCO; i++) {
1004: int fieldNo = cmd.scoFieldNos[i];
1005: buf
1006: .append("\t\tif (_"
1007: + fieldNo
1008: + " instanceof com.versant.core.jdo.sco.VersantSimpleSCO) {\n");
1009: buf
1010: .append("\t\t\t((com.versant.core.jdo.sco.VersantSimpleSCO) _"
1011: + fieldNo + ").makeTransient();\n");
1012: buf.append("\t\t}\n");
1013: }
1014: }
1015: buf.append("\t}\n");
1016: spec.addMethod(buf.toString());
1017: }
1018:
1019: protected void addContainsFetchGroup() {
1020: StringBuffer buf = new StringBuffer();
1021: // public final boolean containsFetchGroup(FetchGroup fetchGroup) {
1022: // for (; fetchGroup != null; fetchGroup = fetchGroup.superFetchGroup) {
1023: // int fgn[] = fetchGroup.stateFieldNos;
1024: // for (int i = fgn.length - 1; i >= 0; i--) {
1025: // if (!containsField(fgn[i])) {
1026: // return false;
1027: // }
1028: // }
1029: //
1030: // }
1031: //
1032: // return true;
1033: // }
1034: buf
1035: .append("\n\tpublic final boolean containsFetchGroup(FetchGroup fetchGroup) {\n");
1036: buf
1037: .append("\t\tfor (; fetchGroup != null; fetchGroup = fetchGroup.superFetchGroup) {\n");
1038: buf.append("\t\t\tint fgn[] = fetchGroup.stateFieldNos;\n");
1039: buf
1040: .append("\t\t\tfor (int i = fgn.length - 1; i >= 0; i--) {\n");
1041: buf.append("\t\t\t\tif (!containsField(fgn[i])) {\n");
1042: buf.append("\t\t\t\t\treturn false;\n");
1043: buf.append("\t\t\t\t}\n");
1044: buf.append("\t\t\t}\n\n");
1045: buf.append("\t\t}\n\n");
1046: buf.append("\t\treturn true;\n");
1047: buf.append("\t}\n");
1048: spec.addMethod(buf.toString());
1049: }
1050:
1051: protected void addClearCollectionFields() {
1052: StringBuffer buf = new StringBuffer();
1053: // public final void clearCollectionFields() {
1054: // filled0 = filled0 & -907265;
1055: // resolved0 = resolved0 & -907265;
1056: // _11 = null;
1057: // _12 = null;
1058: // _14 = null;
1059: // }
1060: buf.append("\n\tpublic final void clearCollectionFields() {\n");
1061: int[] masks = new int[getNumOfControlFields()];
1062: int num = cmd.stateFields.length;
1063: for (int i = 0; i < num; i++) {
1064: int category = cmd.stateFields[i].category;
1065: if (category == MDStatics.CATEGORY_COLLECTION
1066: || category == MDStatics.CATEGORY_MAP
1067: || category == MDStatics.CATEGORY_ARRAY) {
1068: int fieldNum = cmd.stateFields[i].stateFieldNo;
1069: masks[getLocalVarIndex(0, fieldNum)] += getFieldIndex(fieldNum);
1070: }
1071: }
1072: int maskLenght = masks.length;
1073: for (int i = 0; i < maskLenght; i++) {
1074: if (masks[i] != 0) {
1075: buf.append("\t\tfilled" + i + " = filled" + i + " & "
1076: + (masks[i] ^ 0xFFFFFFFF) + ";\n");
1077: buf.append("\t\tresolved" + i + " = resolved" + i
1078: + " & " + (masks[i] ^ 0xFFFFFFFF) + ";\n");
1079: }
1080: }
1081: for (int i = 0; i < num; i++) {
1082: int category = cmd.stateFields[i].category;
1083: if (category == MDStatics.CATEGORY_COLLECTION
1084: || category == MDStatics.CATEGORY_MAP
1085: || category == MDStatics.CATEGORY_ARRAY) {
1086: FieldMetaData data = cmd.stateFields[i];
1087: buf.append("\t\t_" + data.stateFieldNo + " = null;\n");
1088: }
1089: }
1090: buf.append("\t}\n");
1091: spec.addMethod(buf.toString());
1092: }
1093:
1094: protected void addToString() {
1095: StringBuffer buf = new StringBuffer();
1096:
1097: // public String toString() {
1098: // StringBuffer s = new StringBuffer("\n|---------------------------------------------------------------------------------\n| HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_ClassWithSerializableField@");
1099: // s.append(Integer.toHexString(System.identityHashCode(this)));
1100: // s.append("\n|---------------------------------------------------------------------------------");
1101: // s.append("\n| INDEX | FILLED | DIRTY | RESOLVE | NAME | VALUE \n");
1102: // s.append("|---------------------------------------------------------------------------------");
1103: // s.append("\n| 0 ");
1104: // s.append((filled0 & 1) == 0 ? "| 0 " : "| 1 ");
1105: // s.append((dirtyFields0 & 1) == 0 ? "| 0 " : "| 1 ");
1106: // s.append((resolved0 & 1) == 0 ? "| 0 " : "| 1 ");
1107: // s.append("| sr | ");
1108: // s.append(_0);
1109: // s.append("\n| 1 ");
1110: // s.append((filled0 & 2) == 0 ? "| 0 " : "| 1 ");
1111: // s.append((dirtyFields0 & 2) == 0 ? "| 0 " : "| 1 ");
1112: // s.append((resolved0 & 2) == 0 ? "| 0 " : "| 1 ");
1113: // s.append("| val | ");
1114: // s.append(_1);
1115: // s.append("\n| 2 ");
1116: // s.append((filled0 & 4) == 0 ? "| 0 " : "| 1 ");
1117: // s.append((dirtyFields0 & 4) == 0 ? "| 0 " : "| 1 ");
1118: // s.append((resolved0 & 4) == 0 ? "| 0 " : "| 1 ");
1119: // s.append("| jdoVersion | ");
1120: // s.append(_2);
1121: // s.append("\n|---------------------------------------------------------------------------------");
1122: // return s.toString();
1123: // }
1124:
1125: buf.append("\n\tpublic String toString() {\n");
1126: buf
1127: .append("\t\tStringBuffer s = new StringBuffer(\"\\n|---------------------------------------------------------------------------------\\n| "
1128: + className + "@\");\n");
1129: buf.append("\t\ttry{\n");
1130: buf
1131: .append("\t\t\ts.append(Integer.toHexString(System.identityHashCode(this)));\n");
1132: buf
1133: .append("\t\t\ts.append(\"\\n|---------------------------------------------------------------------------------\");\n");
1134:
1135: int maxNameLenght = 0;
1136: for (int j = 0; j < cmd.stateFields.length; j++) {
1137: if (cmd.stateFields[j].name.length() > maxNameLenght) {
1138: maxNameLenght = cmd.stateFields[j].name.length();
1139: }
1140: }
1141: buf
1142: .append("\t\t\ts.append(\"\\n| INDEX | FILLED | DIRTY | RESOLVE | "
1143: + getBufName("NAME", maxNameLenght)
1144: + " | VALUE \\n\");\n");
1145: buf
1146: .append("\t\t\ts.append(\"|---------------------------------------------------------------------------------\");\n");
1147: int totalNum = cmd.stateFields.length;
1148: for (int i = 0; i < totalNum; i++) {
1149: FieldMetaData fmd = cmd.stateFields[i];
1150: int fieldNum = getFieldNo(fmd);
1151: int index = getFieldIndex(fieldNum);
1152: String fieldRealName = fmd.name;
1153: String filledFieldName = getFilledFieldName(fieldNum);
1154: String resolvedFieldName = getResolvedFieldName(fieldNum);
1155: String dirtyFieldName = getDirtyFieldName(fieldNum);
1156: String fieldName = getFieldName(fieldNum);
1157: /* INDEX */
1158: if (fieldNum < 10) {
1159: buf.append("\t\t\ts.append(\"\\n| " + fieldNum
1160: + " \");\n");
1161: } else if (fieldNum < 100) {
1162: buf.append("\t\t\ts.append(\"\\n| " + fieldNum
1163: + " \");\n");
1164: } else {
1165: buf.append("\t\t\ts.append(\"\\n| " + fieldNum
1166: + " \");\n");
1167: }
1168:
1169: /* FILLED */
1170: buf.append("\t\t\ts.append((" + filledFieldName + " & "
1171: + index
1172: + ") == 0 ? \"| 0 \" : \"| 1 \");\n");
1173: /* DIRTY */
1174: buf.append("\t\t\ts.append((" + dirtyFieldName + " & "
1175: + index
1176: + ") == 0 ? \"| 0 \" : \"| 1 \");\n");
1177: /* RESOLVE */
1178: buf.append("\t\t\ts.append((" + resolvedFieldName + " & "
1179: + index
1180: + ") == 0 ? \"| 0 \" : \"| 1 \");\n");
1181: /* NAME */
1182: buf.append("\t\t\ts.append(\"| "
1183: + getBufName(fieldRealName, maxNameLenght)
1184: + " | \");\n");
1185: /* VALUE */
1186: if (isOID(fmd)) {
1187: buf.append("\t\t\ts.append((" + fieldName
1188: + " instanceof OID) ? ((Object) (((OID)"
1189: + fieldName + ").toSString())) : " + fieldName
1190: + ");\n");
1191: } else {
1192: buf.append("\t\t\ts.append(" + fieldName + ");\n");
1193: }
1194: }
1195: buf
1196: .append("\t\t\ts.append(\"\\n|---------------------------------------------------------------------------------\");\n");
1197: buf.append("\t\t} catch(java.lang.Exception e){\n");
1198: buf.append("\t\t\ts = new StringBuffer(e.getMessage());\n");
1199: buf.append("\t\t}\n");
1200: buf.append("\t\treturn s.toString();\n");
1201: buf.append("\t}\n");
1202: spec.addMethod(buf.toString());
1203:
1204: }
1205:
1206: protected String getBufName(String name, int maxLenght) {
1207: int bufLenght = maxLenght - name.length();
1208: StringBuffer buf = new StringBuffer(name);
1209: for (int i = 0; i < bufLenght; i++) {
1210: buf.append(" ");
1211: }
1212: return buf.toString();
1213: }
1214:
1215: protected void addClearTransactionNonPersistentFields() {
1216: StringBuffer buf = new StringBuffer();
1217: // public final void clearTransactionNonPersistentFields() {
1218: // dirtyFields0 = dirtyFields0 & -1048577;
1219: // }
1220: buf
1221: .append("\n\tpublic final void clearTransactionNonPersistentFields() {\n");
1222: int[] masks = new int[getNumOfControlFields()];
1223: int num = cmd.txFieldNos.length;
1224: for (int i = 0; i < num; i++) {
1225: int fieldNum = cmd.txFieldNos[i];
1226: masks[getLocalVarIndex(0, fieldNum)] += getFieldIndex(fieldNum);
1227: }
1228: int maskLenght = masks.length;
1229: for (int i = 0; i < maskLenght; i++) {
1230: if (masks[i] != 0) {
1231: buf.append("\t\tdirtyFields" + i + " = dirtyFields" + i
1232: + " & " + (masks[i] ^ 0xFFFFFFFF) + ";\n");
1233: }
1234: }
1235: buf.append("\t}\n");
1236: spec.addMethod(buf.toString());
1237: }
1238:
1239: protected void addCompareToPass1() {
1240: StringBuffer buf = new StringBuffer();
1241: // public final int compareToPass1(State state) {
1242: // HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff s = (HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff) state;
1243: // int ans = ((filled0 & -2) - (s.filled0 & -2)) + ((filled1 & -1) - (s.filled1 & -1)) + ((filled2 & 33791) - (s.filled2 & 33791));
1244: // }
1245:
1246: // buf.append("\n\tpublic final boolean isEmpty() {\n");
1247: // int num = getNumOfControlFields();
1248: // for (int i = 0; i < num; i++) {
1249: // if (i == 0) {
1250: // buf.append("\t\treturn filled0 == 0");
1251: // } else {
1252: // buf.append(" && filled" + i + " == 0");
1253: // }
1254: // }
1255: // buf.append(";\n");
1256: // buf.append("\t}\n");
1257:
1258: buf
1259: .append("\n\tpublic final int compareToPass1(State state) {\n");
1260: buf.append("\t\t" + className + " s = (" + className
1261: + ") state;\n");
1262: int[] masks = new int[getNumOfControlFields()];
1263: int num = cmd.stateFields.length;
1264: for (int i = 0; i < num; i++) {
1265: if (cmd.stateFields[i].primaryField) {
1266: int fieldNum = cmd.stateFields[i].stateFieldNo;
1267: masks[getLocalVarIndex(0, fieldNum)] += getFieldIndex(fieldNum);
1268: }
1269: }
1270: int maskLenght = masks.length;
1271: for (int i = 0; i < maskLenght; i++) {
1272: if (i == 0) {
1273: buf.append("\t\tint ans = ((filled0 & " + masks[i]
1274: + ") - (s.filled0 & " + masks[i] + "))");
1275: } else {
1276: buf
1277: .append(" + ((filled" + i + " & " + masks[i]
1278: + ") - (s.filled" + i + " & "
1279: + masks[i] + "))");
1280: }
1281:
1282: }
1283: buf.append(";\n");
1284: buf.append("\t\treturn ans;\n");
1285: buf.append("\t}\n");
1286: spec.addMethod(buf.toString());
1287: }
1288:
1289: protected void addGetClassMetaDataJMD() {
1290: StringBuffer buf = new StringBuffer();
1291: buf
1292: .append("\n\tpublic final ClassMetaData getClassMetaData(ModelMetaData jmd) {\n");
1293: buf.append("\t\treturn cmd;\n");
1294: buf.append("\t}\n");
1295: spec.addMethod(buf.toString());
1296: }
1297:
1298: protected void addGetClassMetaData() {
1299: StringBuffer buf = new StringBuffer();
1300: // public final ClassMetaData getClassMetaData() {
1301: // return cmd;
1302: // }
1303: buf
1304: .append("\n\tpublic final ClassMetaData getClassMetaData() {\n");
1305: buf.append("\t\treturn cmd;\n");
1306: buf.append("\t}\n");
1307: spec.addMethod(buf.toString());
1308: }
1309:
1310: protected void addContainFields() {
1311: StringBuffer buf = new StringBuffer();
1312:
1313: // public final boolean containFields(int fieldNos[]) {
1314: // int numOfFields = fieldNos.length;
1315: // for (int i = 0; i < numOfFields; i++) {
1316: // if (!containsField(fieldNos[i])) {
1317: // return false;
1318: // }
1319: // }
1320: // return true;
1321: // }
1322:
1323: // public final boolean containFields(int fieldNos[]) {
1324: // int numOfFields = fieldNos.length;
1325: // for (int i = 0; i < numOfFields; i++) {
1326: // if ((filled0 & 1 << fieldNos[i]) == 0) {
1327: // return false;
1328: // }
1329: // }
1330: // return true;
1331: // }
1332:
1333: buf
1334: .append("\n\tpublic final boolean containFields(int fieldNos[]) {\n");
1335: buf.append("\t\tint numOfFields = fieldNos.length;\n");
1336: buf.append("\t\tfor (int i = 0; i < numOfFields; i++) {\n");
1337: int controlNum = getNumOfControlFields();
1338: if (controlNum == 1) {
1339: buf
1340: .append("\t\t\tif ((filled0 & 1 << fieldNos[i]) == 0) {\n");
1341:
1342: } else { // if there is multiple control field we just call the method containsField, else it get hairy.
1343: buf.append("\t\t\tif (!containsField(fieldNos[i])) {\n");
1344: }
1345: buf.append("\t\t\t\treturn false;\n");
1346: buf.append("\t\t\t}\n");
1347: buf.append("\t\t}\n\n");
1348: buf.append("\t\treturn true;\n");
1349: buf.append("\t}\n");
1350: spec.addMethod(buf.toString());
1351: }
1352:
1353: protected void addContainFieldsAbs() {
1354: StringBuffer buf = new StringBuffer();
1355: // public final boolean containFieldsAbs(int absfieldNos[]) {
1356: // int numOfFields = absfieldNos.length;
1357: // int managedFieldNos[] = cmd.absToRel;
1358: // for (int i = 0; i < numOfFields; i++) {
1359: // if (!containsField(managedFieldNos[absfieldNos[i]])) {
1360: // return false;
1361: // }
1362: // }
1363: // return true;
1364: // }
1365: buf
1366: .append("\n\tpublic final boolean containFieldsAbs(int absfieldNos[]) {\n");
1367: buf.append("\t\tint numOfFields = absfieldNos.length;\n");
1368: buf.append("\t\tint managedFieldNos[] = cmd.absToRel;\n");
1369: buf.append("\t\tfor (int i = 0; i < numOfFields; i++) {\n");
1370: buf
1371: .append("\t\t\tif (!containsField(managedFieldNos[absfieldNos[i]])) {\n");
1372: buf.append("\t\t\t\treturn false;\n");
1373: buf.append("\t\t\t}\n");
1374: buf.append("\t\t}\n");
1375: buf.append("\t\treturn true;\n");
1376: buf.append("\t}\n");
1377: spec.addMethod(buf.toString());
1378: }
1379:
1380: protected void addIsEmpty() {
1381: StringBuffer buf = new StringBuffer();
1382:
1383: // public final boolean isEmpty() {
1384: // return filled0 == 0 && filled1 == 0 && filled2 == 0;
1385: // }
1386:
1387: buf.append("\n\tpublic final boolean isEmpty() {\n");
1388: int num = getNumOfControlFields();
1389: for (int i = 0; i < num; i++) {
1390: if (i == 0) {
1391: buf.append("\t\treturn filled0 == 0");
1392: } else {
1393: buf.append(" && filled" + i + " == 0");
1394: }
1395: }
1396: buf.append(";\n");
1397: buf.append("\t}\n");
1398: spec.addMethod(buf.toString());
1399: }
1400:
1401: protected void addContainsPass2Fields() {
1402: StringBuffer buf = new StringBuffer();
1403: buf
1404: .append("\n\tpublic final boolean containsPass2Fields() {\n");
1405: boolean doMask = false;
1406: int[] masks = new int[getNumOfControlFields()];
1407: int num = cmd.stateFields.length;
1408: for (int i = 0; i < num; i++) {
1409: if (cmd.stateFields[i].secondaryField) {
1410: int fieldNum = cmd.stateFields[i].stateFieldNo;
1411: doMask = true;
1412: masks[getLocalVarIndex(0, fieldNum)] += getFieldIndex(fieldNum);
1413: }
1414: }
1415: if (!doMask) {
1416: buf.append("\t\treturn false;\n");
1417: } else {
1418: for (int i = 0; i < masks.length; i++) {
1419: buf.append("\t\tif ((filled" + i + " & " + masks[i]
1420: + ") != 0) {\n");
1421: buf.append("\t\t\treturn true;\n");
1422: buf.append("\t\t}\n");
1423: }
1424: buf.append("\t\treturn false;\n");
1425: }
1426: buf.append("\t}\n");
1427: spec.addMethod(buf.toString());
1428: }
1429:
1430: protected void addContainsPass1Fields() {
1431: StringBuffer buf = new StringBuffer();
1432: // public final boolean containsPass1Fields() {
1433: // if ((filled0 & -2) != 0) {
1434: // return true;
1435: // }
1436: // if ((filled1 & -1) != 0) {
1437: // return true;
1438: // }
1439: // return (filled2 & 33791) != 0;
1440: // }
1441: buf
1442: .append("\n\tpublic final boolean containsPass1Fields() {\n");
1443: boolean doMask = false;
1444: int[] masks = new int[getNumOfControlFields()];
1445: int num = cmd.stateFields.length;
1446: for (int i = 0; i < num; i++) {
1447: if (cmd.stateFields[i].primaryField) {
1448: int fieldNum = cmd.stateFields[i].stateFieldNo;
1449: doMask = true;
1450: masks[getLocalVarIndex(0, fieldNum)] += getFieldIndex(fieldNum);
1451: }
1452: }
1453: if (!doMask) {
1454: buf.append("\t\treturn false;\n");
1455: } else {
1456: for (int i = 0; i < masks.length; i++) {
1457: buf.append("\t\tif ((filled" + i + " & " + masks[i]
1458: + ") != 0) {\n");
1459: buf.append("\t\t\treturn true;\n");
1460: buf.append("\t\t}\n");
1461: }
1462: buf.append("\t\treturn false;\n");
1463: }
1464: buf.append("\t}\n");
1465: spec.addMethod(buf.toString());
1466: }
1467:
1468: protected void addGetPass1FieldNos() {
1469: StringBuffer buf = new StringBuffer();
1470: // public final int getPass1FieldNos(int buf[]) {
1471: // int c = 0;
1472: // int filled = filled0;
1473: // if ((filled & 2) != 0) {
1474: // buf[c++] = 1;
1475: // }
1476: // if ((filled & -2147483648) != 0) {
1477: // buf[c++] = 31;
1478: // }
1479: // filled = filled1;
1480: // if ((filled & 1) != 0) {
1481: // buf[c++] = 32;
1482: // }
1483: // if ((filled & 32768) != 0) {
1484: // buf[c++] = 79;
1485: // }
1486: // return c;
1487: // }
1488:
1489: buf
1490: .append("\n\tpublic final int getPass1FieldNos(int buf[]) {\n");
1491: buf.append("\t\tint c = 0;\n");
1492: boolean first = true; // flag
1493: int num = getNumOfControlFields();
1494: for (int i = 0; i < num; i++) {
1495: List fields = getPass1Fields(i);
1496: if (fields.isEmpty()) {
1497: continue;
1498: }
1499: if (first) {
1500: buf.append("\t\tint filled = filled" + i + ";\n");
1501: first = false;
1502: } else {
1503: buf.append("\t\tfilled = filled" + i + ";\n");
1504: }
1505: for (Iterator iter = fields.iterator(); iter.hasNext();) {
1506: FieldMetaData fmd = (FieldMetaData) iter.next();
1507: int fieldNo = fmd.stateFieldNo;
1508: buf.append("\t\tif ((filled & "
1509: + getFieldIndex(fieldNo) + ") != 0) {\n");
1510: buf.append("\t\t\tbuf[c++] = " + fieldNo + ";\n");
1511: buf.append("\t\t}\n");
1512: }
1513: }
1514: buf.append("\t\treturn c;\n");
1515: buf.append("\t\t}\n");
1516: spec.addMethod(buf.toString());
1517: }
1518:
1519: protected void addGetPass1FieldRefFieldNosWithNewOids() {
1520: StringBuffer buf = new StringBuffer();
1521: // public final int getPass1FieldNos(int buf[]) {
1522: // int c = 0;
1523: // int filled = filled0;
1524: // if ((filled & 2) != 0) {
1525: // buf[c++] = 1;
1526: // }
1527: // if ((filled & -2147483648) != 0) {
1528: // buf[c++] = 31;
1529: // }
1530: // filled = filled1;
1531: // if ((filled & 1) != 0) {
1532: // buf[c++] = 32;
1533: // }
1534: // if ((filled & 32768) != 0) {
1535: // buf[c++] = 79;
1536: // }
1537: // return c;
1538: // }
1539:
1540: buf
1541: .append("\n\tpublic final int getPass1FieldRefFieldNosWithNewOids(int buf[]) {\n");
1542: buf.append("\t\tint c = 0;\n");
1543: boolean first = true; // flag
1544: int num = getNumOfControlFields();
1545: for (int i = 0; i < num; i++) {
1546: List fields = getPass1FieldAndRefOrPolyRefFields(i);
1547: if (fields.isEmpty()) {
1548: continue;
1549: }
1550: if (first) {
1551: buf.append("\t\tint filled = filled" + i + ";\n");
1552: first = false;
1553: } else {
1554: buf.append("\t\tfilled = filled" + i + ";\n");
1555: }
1556: for (Iterator iter = fields.iterator(); iter.hasNext();) {
1557: FieldMetaData fmd = (FieldMetaData) iter.next();
1558: int fieldNo = fmd.stateFieldNo;
1559: buf.append("\t\tif ((filled & "
1560: + getFieldIndex(fieldNo) + ") != 0) {\n");
1561: buf.append("\t\t\tbuf[c++] = " + fieldNo + ";\n");
1562: buf.append("\t\t}\n");
1563: }
1564: }
1565: buf.append("\t\treturn c;\n");
1566: buf.append("\t\t}\n");
1567: spec.addMethod(buf.toString());
1568: }
1569:
1570: protected void addGetPass2FieldNos() {
1571: StringBuffer buf = new StringBuffer();
1572: buf
1573: .append("\n\tpublic final int getPass2FieldNos(int buf[]) {\n");
1574: buf.append("\t\tint c = 0;\n");
1575: boolean first = true; // flag
1576: int num = getNumOfControlFields();
1577: for (int i = 0; i < num; i++) {
1578: List fields = getPass2Fields(i);
1579: if (fields.isEmpty()) {
1580: continue;
1581: }
1582: if (first) {
1583: buf.append("\t\tint filled = filled" + i + ";\n");
1584: first = false;
1585: } else {
1586: buf.append("\t\tfilled = filled" + i + ";\n");
1587: }
1588: for (Iterator iter = fields.iterator(); iter.hasNext();) {
1589: FieldMetaData fmd = (FieldMetaData) iter.next();
1590: int fieldNo = fmd.stateFieldNo;
1591: buf.append("\t\tif ((filled & "
1592: + getFieldIndex(fieldNo) + ") != 0) {\n");
1593: buf.append("\t\t\tbuf[c++] = " + fieldNo + ";\n");
1594: buf.append("\t\t}\n");
1595: }
1596: }
1597: buf.append("\t\treturn c;\n");
1598: buf.append("\t\t}\n");
1599: spec.addMethod(buf.toString());
1600: }
1601:
1602: protected void addIsHollow() {
1603: StringBuffer buf = new StringBuffer();
1604: // public final boolean isHollow() {
1605: // return filled0 == 0 && filled1 == 0 && filled2 == 0;
1606: // }
1607:
1608: buf.append("\n\tpublic final boolean isHollow() {\n");
1609: int num = getNumOfControlFields();
1610: for (int i = 0; i < num; i++) {
1611: if (i == 0) {
1612: buf.append("\t\treturn filled0 == 0");
1613: } else {
1614: buf.append(" && filled" + i + " == 0");
1615: }
1616: }
1617: buf.append(";\n");
1618: buf.append("\t}\n");
1619: spec.addMethod(buf.toString());
1620: }
1621:
1622: protected void addSetClassMetaData() {
1623: StringBuffer buf = new StringBuffer();
1624: buf
1625: .append("\n\tpublic final void setClassMetaData(ClassMetaData classmetadata) {\n\t}\n");
1626: spec.addMethod(buf.toString());
1627: }
1628:
1629: protected void addReplaceNewObjectOIDs() {
1630: StringBuffer buf = new StringBuffer();
1631: // public final void replaceNewObjectOIDs(int fieldNos[], int fieldNosLength) {
1632: // for (int i = 0; i < fieldNosLength; i++) {
1633: // switch (fieldNos[i]) {
1634: // case 0: // '\0'
1635: // if (_0 instanceof NewObjectOID) {
1636: // if (((com.versant.core.common.NewObjectOID) _1).realOID == null) {
1637: // containsUnResolvedNewOids = true;
1638: // } else {
1639: // _1 = ((com.versant.core.common.NewObjectOID) _1).realOID;
1640: // }
1641: // }
1642: // break;
1643: // default:
1644: // break;
1645: // }
1646: // }
1647: // }
1648: buf
1649: .append("\n\tpublic final boolean replaceNewObjectOIDs(int fieldNos[], int fieldNosLength) {\n");
1650: List oidList = getOIDsFieldsMetaData();
1651: if (oidList.isEmpty()) {
1652: buf.append("\t\treturn false;\n");
1653: buf.append("\t}\n");
1654: } else {
1655: buf
1656: .append("\t\tboolean containsUnResolvedNewOids = false;\n");
1657: buf
1658: .append("\t\tfor (int i = 0; i < fieldNosLength; i++) {\n");
1659: buf.append("\t\t\tswitch (fieldNos[i]) {\n");
1660: for (Iterator iter = oidList.iterator(); iter.hasNext();) {
1661: FieldMetaData field = (FieldMetaData) iter.next();
1662: int fieldNo = field.stateFieldNo;
1663: buf.append("\t\t\t\tcase " + fieldNo + ":\n");
1664: buf
1665: .append("\t\t\t\t\tif (_"
1666: + fieldNo
1667: + " instanceof com.versant.core.common.NewObjectOID) {\n");
1668: buf
1669: .append("\t\t\t\t\t\tif (((com.versant.core.common.NewObjectOID) _"
1670: + fieldNo + ").realOID == null) {\n");
1671: buf
1672: .append("\t\t\t\t\t\t\tcontainsUnResolvedNewOids = true;\n");
1673: buf.append("\t\t\t\t\t\t} else {\n");
1674: buf
1675: .append("\t\t\t\t\t\t\t_"
1676: + fieldNo
1677: + " = ((com.versant.core.common.NewObjectOID) _"
1678: + fieldNo + ").realOID;\n");
1679: buf.append("\t\t\t\t\t\t}\n");
1680: buf.append("\t\t\t\t\t}\n");
1681: buf.append("\t\t\t\t\tbreak;\n\n");
1682: }
1683: // Do default
1684: buf.append("\t\t\t\tdefault:\n");
1685: buf.append("\t\t\t\t\tbreak;\n\n");
1686: buf.append("\t\t\t}\n");
1687: buf.append("\t\t}\n");
1688: buf.append("\t\treturn containsUnResolvedNewOids;\n");
1689: buf.append("\t}\n");
1690: }
1691: spec.addMethod(buf.toString());
1692: }
1693:
1694: protected void addGetDirtyState() {
1695: StringBuffer buf = new StringBuffer();
1696: buf
1697: .append("\n\tpublic boolean fillToStoreState(State stateToStore, PersistenceContext pm, VersantStateManager sm) {\n");
1698: if (!cmd.storeAllFields) {
1699: buf.append("\t\t" + className + " state = (" + className
1700: + ")stateToStore;\n");
1701: buf.append("\t\tif (isDirty()) {\n");
1702: buf.append("\t\t\tboolean prepare = false;\n");
1703: int num = getNumOfControlFields();
1704: for (int i = 0; i < num; i++) {
1705: if (i == 0) {
1706: buf.append("\t\t\tint toCheck = state.filled" + i
1707: + " = dirtyFields" + i + ";\n");
1708: } else {
1709: buf.append("\t\t\ttoCheck = state.filled" + i
1710: + " = dirtyFields" + i + ";\n");
1711: }
1712: List fields = getFields(i);
1713: for (Iterator iter = fields.iterator(); iter.hasNext();) {
1714: FieldMetaData fmd = (FieldMetaData) iter.next();
1715: int fieldNo = fmd.stateFieldNo;
1716: buf.append("\t\t\tif ((toCheck & "
1717: + getFieldIndex(fieldNo) + ") != 0) {\n");
1718: if (isOID(fmd) || isCollection(fmd) || isMap(fmd)
1719: || isPolyRef(fmd) || isPCArray(fmd)
1720: || isExternalized(fmd)) {
1721: buf.append("\t\t\t\tprepare = true;\n");
1722: } else if (fmd.type.equals(java.util.Date.class)) {
1723: buf.append("\t\t\t\tprepare = true;\n");
1724: }
1725: buf.append("\t\t\t\tstate._" + fieldNo + " = _"
1726: + fieldNo + ";\n");
1727: buf.append("\t\t\t}\n");
1728: }
1729: }
1730: buf.append("\t\t\tif (prepare) {\n");
1731: buf.append("\t\t\t\tstate.prepare(pm, sm);\n");
1732: buf.append("\t\t\t}\n");
1733: buf.append("\t\t} else {\n");
1734: buf.append("\t\t\tstate = null;\n");
1735: buf.append("\t\t}\n");
1736: buf.append("\t\treturn state != null;\n");
1737: } else { // vds store
1738: buf.append("\t\t" + className + " state = (" + className
1739: + ")stateToStore;\n");
1740: buf.append("\t\tif (isDirty()) {\n");
1741: int num = getNumOfControlFields();
1742: boolean toCheck_Start = true;
1743: for (int i = 0; i < num; i++) {
1744: int hash = getPrimaryHash(i);
1745: if (hash == 0) {
1746: continue;
1747: }
1748: if (toCheck_Start) {
1749: buf.append("\t\t\tint toCheck = state.filled" + i
1750: + " |= filled" + i + " & " + hash + ";\n");
1751: toCheck_Start = false;
1752: } else {
1753: buf.append("\t\t\ttoCheck = state.filled" + i
1754: + " |= filled" + i + " & " + hash + ";\n");
1755: }
1756: List fields = getPrimaryFields(i);
1757: for (Iterator iter = fields.iterator(); iter.hasNext();) {
1758: FieldMetaData fmd = (FieldMetaData) iter.next();
1759: int fieldNo = fmd.stateFieldNo;
1760: buf.append("\t\t\tif ((toCheck & "
1761: + getFieldIndex(fieldNo) + ") != 0) {\n");
1762: buf.append("\t\t\t\tstate._" + fieldNo + " = _"
1763: + fieldNo + ";\n");
1764: buf.append("\t\t\t}\n");
1765: }
1766: }
1767:
1768: for (int i = 0; i < num; i++) {
1769: int hash = getSecondaryHash(i);
1770: if (hash == 0) {
1771: continue;
1772: }
1773: if (toCheck_Start) {
1774: buf.append("\t\t\tint toCheck = state.filled" + i
1775: + " |= dirtyFields" + i + " & " + hash
1776: + ";\n");
1777: toCheck_Start = false;
1778: } else {
1779: buf.append("\t\t\ttoCheck = state.filled" + i
1780: + " |= dirtyFields" + i + " & " + hash
1781: + ";\n");
1782: }
1783: List fields = getSecondaryFields(i);
1784: for (Iterator iter = fields.iterator(); iter.hasNext();) {
1785: FieldMetaData fmd = (FieldMetaData) iter.next();
1786: int fieldNo = fmd.stateFieldNo;
1787: buf.append("\t\t\tif ((toCheck & "
1788: + getFieldIndex(fieldNo) + ") != 0) {\n");
1789: buf.append("\t\t\t\tstate._" + fieldNo + " = _"
1790: + fieldNo + ";\n");
1791: buf.append("\t\t\t}\n");
1792: }
1793: }
1794: buf.append("\t\t\tstate.prepare(pm, sm);\n");
1795: buf.append("\t\t} else {\n");
1796: buf.append("\t\t\tstate = null;\n");
1797: buf.append("\t\t}\n");
1798: buf.append("\t\treturn state != null;\n");
1799: }
1800: buf.append("\t}\n");
1801: spec.addMethod(buf.toString());
1802: }
1803:
1804: protected void addFindDirectEdges() {
1805: StringBuffer buf = new StringBuffer();
1806: buf
1807: .append("\n\tpublic final void findDirectEdges(OIDGraph graph, "
1808: + INT_ARRAY + " edges) {\n");
1809: List list = getDirectRefFieldsMetaData();
1810: if (list.isEmpty()) {
1811: buf.append("\t}\n");
1812: } else {
1813: ListIterator iter = list.listIterator();
1814: while (iter.hasNext()) {
1815: iter.next();
1816: }
1817: while (iter.hasPrevious()) {
1818: FieldMetaData field = (FieldMetaData) iter.previous();
1819: int fieldNum = field.stateFieldNo;
1820: int index = getFieldIndex(fieldNum);
1821: String filledName = getFilledFieldName(fieldNum);
1822:
1823: buf.append("\t\tif ((" + filledName + " & " + index
1824: + ") != 0) {\n");
1825: buf.append("\t\t\tfindDirectEdges(graph, cmd, "
1826: + fieldNum + ", this, edges);\n");
1827: buf.append("\t\t}\n");
1828: }
1829: buf.append("\t}\n");
1830: }
1831: spec.addMethod(buf.toString());
1832: }
1833:
1834: protected void addHasSameNullFields() {
1835: StringBuffer buf = new StringBuffer();
1836: buf
1837: .append("\n\tpublic final boolean hasSameNullFields(State state, State mask) {\n");
1838: buf.append("\t\treturn true;\n");
1839: buf.append("\t}\n");
1840: spec.addMethod(buf.toString());
1841: }
1842:
1843: protected void addIsNull() {
1844: StringBuffer buf = new StringBuffer();
1845: buf.append("\n\tpublic final boolean isNull(int fieldNo) {\n");
1846: List fields = getAllRealObjectFields();
1847: if (fields.isEmpty()) {
1848: buf.append("\t\treturn false;\n");
1849: } else if (fields.size() == 1) {
1850: for (Iterator iter = fields.iterator(); iter.hasNext();) {
1851: int fieldNo = getFieldNo((FieldMetaData) iter.next());
1852: buf.append("\t\treturn _" + fieldNo + " == null;\n");
1853: }
1854: } else {
1855: buf.append("\t\tswitch (fieldNo) {\n");
1856: for (Iterator fieldIter = fields.iterator(); fieldIter
1857: .hasNext();) {
1858: FieldMetaData info = (FieldMetaData) fieldIter.next();
1859: int fieldNo = getFieldNo(info);
1860: buf.append("\t\t\tcase " + fieldNo + ":\n");
1861: buf.append("\t\t\t\treturn _" + fieldNo
1862: + " == null;\n\n");
1863: }
1864: buf.append("\t\t\tdefault:\n");
1865: buf.append("\t\t\t\treturn false;\n");
1866: buf.append("\t\t}\n");
1867: }
1868: buf.append("\t}\n");
1869: spec.addMethod(buf.toString());
1870: }
1871:
1872: protected FetchGroup findFirstRefFG(ClassMetaData cmd) {
1873: if (cmd.refFetchGroup != null)
1874: return cmd.refFetchGroup;
1875: if (cmd.refFetchGroup == null && cmd.pcSuperMetaData == null)
1876: return null;
1877: return findFirstRefFG(cmd.pcSuperMetaData);
1878: }
1879:
1880: protected void addAddRefs() {
1881: StringBuffer buf = new StringBuffer();
1882: buf
1883: .append("\n\tpublic final void addRefs(VersantPersistenceManagerImp pm, PCStateMan sm) {\n");
1884: FetchGroup fg = findFirstRefFG(cmd);//cmd.refFetchGroup;
1885: // do if (isDirty()){ only do this if refFetchGroup != null
1886: if (fg != null) {
1887: buf.append("\t\tif (isDirty()) {\n");
1888: while (fg != null) {
1889: int[] fieldNos = fg.stateFieldNos;
1890: int fieldNum = 0;
1891: FieldMetaData fmd = null;
1892: // the fields MUST be processed in ascending order or embedded
1893: // reference fields containing other embedded reference fields
1894: // will not work as the embedded-embedded field will be
1895: // processed prior to being filled
1896: for (int i = 0; i < fieldNos.length; i++) {
1897: fieldNum = fieldNos[i];
1898: fmd = cmd.stateFields[fieldNum];
1899: if (fmd.persistenceModifier == MDStatics.PERSISTENCE_MODIFIER_TRANSACTIONAL) {
1900: continue;
1901: }
1902: buf.append("\t\t\tif (("
1903: + getDirtyFieldName(fieldNum) + " & "
1904: + getFieldIndex(fieldNum) + ") != 0 && _"
1905: + fieldNum + " != null) {\n");
1906: switch (fmd.category) {
1907: case MDStatics.CATEGORY_ARRAY:
1908: // do StateUtil.doReachable((Object[])data[fieldNo], pm);
1909: buf
1910: .append("\t\t\t\tStateUtil.doReachable((Object[])_"
1911: + fieldNum + ", pm);\n");
1912: break;
1913: case MDStatics.CATEGORY_COLLECTION:
1914: // do StateUtil.doReachable((Collection)data[fieldNo], pm); java.util.Collection
1915: buf
1916: .append("\t\t\t\tStateUtil.doReachable((java.util.Collection)_"
1917: + fieldNum + ", pm);\n");
1918: break;
1919: case MDStatics.CATEGORY_MAP:
1920: buf
1921: .append("\t\t\t\tStateUtil.doReachable((java.util.Map) _"
1922: + fieldNum
1923: + ", pm, cmd.stateFields["
1924: + fieldNum + "]);\n");
1925: break;
1926: case MDStatics.CATEGORY_REF:
1927: case MDStatics.CATEGORY_POLYREF:
1928: if (fmd.embedded) {
1929: buf
1930: .append("\t\t\t\t\tStateUtil.doReachableEmbeddedReference(\n"
1931: + "\t\t\t\t\t\t(PersistenceCapable)_"
1932: + fieldNum
1933: + ", pm, sm, cmd.stateFields["
1934: + fieldNum + "]);\n");
1935: } else {
1936: buf
1937: .append("\t\t\t\t\tStateUtil.doReachable((PersistenceCapable)_"
1938: + fieldNum + ", pm);\n");
1939: }
1940: break;
1941: default:
1942: fmd.dump();
1943: throw BindingSupportImpl.getInstance()
1944: .internal("className = " + className);
1945: }
1946: buf.append("\t\t\t}\n");
1947: }
1948: fg = fg.super FetchGroup;
1949: }
1950: buf.append("\t\t}\n");
1951: }
1952: buf.append("\t}\n");
1953: spec.addMethod(buf.toString());
1954: }
1955:
1956: protected void addRetrieve() {
1957: StringBuffer buf = new StringBuffer();
1958: buf
1959: .append("\n\tpublic final void retrieve(VersantPersistenceManagerImp sm) {\n");
1960: FetchGroup fg = cmd.refFetchGroup;
1961: if (fg != null) {
1962: while (fg != null) {
1963: int[] fieldNos = fg.stateFieldNos;
1964: int fieldNum = 0;
1965: FieldMetaData fmd = null;
1966: for (int i = fieldNos.length - 1; i >= 0; i--) {
1967: fieldNum = fieldNos[i];
1968: fmd = cmd.stateFields[fieldNum];
1969: if (fmd.persistenceModifier == MDStatics.PERSISTENCE_MODIFIER_TRANSACTIONAL) {
1970: continue;
1971: }
1972: buf
1973: .append("\t\tif (_" + fieldNum
1974: + " != null) {\n");
1975: switch (fmd.category) {
1976: case MDStatics.CATEGORY_ARRAY:
1977: buf
1978: .append("\t\t\tsm.retrieveAllImp((Object[])_"
1979: + fieldNum + ");\n");
1980: break;
1981: case MDStatics.CATEGORY_COLLECTION:
1982: buf
1983: .append("\t\t\tsm.retrieveAllImp((java.util.Collection)_"
1984: + fieldNum + ");\n");
1985: break;
1986: case MDStatics.CATEGORY_MAP:
1987: buf
1988: .append("\t\t\tStateUtil.retrieve((java.util.Map) _"
1989: + fieldNum
1990: + ", sm, cmd.stateFields["
1991: + fieldNum + "]);\n");
1992: break;
1993: case MDStatics.CATEGORY_REF:
1994: case MDStatics.CATEGORY_POLYREF:
1995: buf.append("\t\t\tsm.retrieveImp(_" + fieldNum
1996: + ");\n");
1997: break;
1998:
1999: default:
2000: fmd.dump();
2001: throw BindingSupportImpl.getInstance()
2002: .internal("className = " + className);
2003: }
2004: buf.append("\t\t}\n");
2005: }
2006: fg = fg.super FetchGroup;
2007: }
2008: }
2009: buf.append("\t}\n");
2010: spec.addMethod(buf.toString());
2011:
2012: }
2013:
2014: protected void addGetResolvableObjectField() {
2015: StringBuffer buf = new StringBuffer();
2016: buf
2017: .append("\n\tpublic Object getObjectField(int stateFieldNo, PersistenceCapable owningPC, PersistenceContext pm, OID oid) {\n");
2018: List fields = getObjectFieldsMetaData();
2019: if (fields.isEmpty()) {
2020: buf
2021: .append("\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
2022: } else if (fields.size() == 1) {
2023: for (Iterator singelIter = fields.iterator(); singelIter
2024: .hasNext();) {
2025: FieldMetaData info = (FieldMetaData) singelIter.next();
2026: int fieldNo = getFieldNo(info);
2027: buf.append("\t\tif (stateFieldNo == " + fieldNo
2028: + "){\n");
2029: addGetResolvableObjectFieldImp(info, buf, fieldNo);
2030: buf.append("\t\t} else {\n");
2031: buf
2032: .append("\t\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
2033: buf.append("\t\t}\n");
2034: }
2035: } else {
2036: buf.append("\t\tswitch (stateFieldNo) {\n");
2037: for (Iterator fieldIter = fields.iterator(); fieldIter
2038: .hasNext();) {
2039: FieldMetaData info = (FieldMetaData) fieldIter.next();
2040: int fieldNo = getFieldNo(info);
2041: buf.append("\t\t\tcase " + fieldNo + ":\n");
2042: addGetResolvableObjectFieldImp(info, buf, fieldNo);
2043: }
2044: buf.append("\t\t\tdefault :\n");
2045: buf
2046: .append("\t\t\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
2047: buf.append("\t\t}\n");
2048: }
2049: buf.append("\t}\n");
2050: spec.addMethod(buf.toString());
2051: }
2052:
2053: protected void addGetResolvableObjectFieldImp(FieldMetaData info,
2054: StringBuffer buf, int fieldNo) {
2055: if (cmd.isEmbeddedRef(fieldNo)) {
2056: buf.append("\t\t\t\tif (_" + fieldNo + " == null && ("
2057: + getResolvedFieldName(fieldNo) + " & "
2058: + getFieldIndex(fieldNo) + ") == 0) {\n");
2059: buf.append("\t\t\t\t\t_" + fieldNo
2060: + " = pm.getObjectByIdForState(null, " + fieldNo
2061: + ", " + cmd.index + ", oid);\n");
2062: buf.append("\t\t\t\t\t" + getResolvedFieldName(fieldNo)
2063: + " |= " + getFieldIndex(fieldNo) + ";\n");
2064: buf.append("\t\t\t\t};\n");
2065: buf.append("\t\t\t\treturn _" + fieldNo + ";\n");
2066: return;
2067: }
2068: boolean done = false;
2069: if (info.scoField) {
2070: if (info.category == MDStatics.CATEGORY_ARRAY) {
2071: if (info.isElementTypePC()) {
2072: buf.append("\t\t\tif (_" + fieldNo
2073: + " != null) {\n");
2074: buf.append("\t\t\t\tif (("
2075: + getResolvedFieldName(fieldNo) + " & "
2076: + getFieldIndex(fieldNo) + ") == 0) {\n");
2077: buf.append("\t\t\t\t\t_" + fieldNo
2078: + " = resolveArrayOIDs((Object[]) _"
2079: + fieldNo + ", pm, cmd.stateFields["
2080: + fieldNo + "].elementType);\n");
2081: done = true;
2082: }
2083: } else {
2084: boolean isDate = info.typeCode == MDStatics.DATE;
2085: buf.append("\t\t\tif (_" + fieldNo + " != null) {\n");
2086: buf.append("\t\t\t\tif (("
2087: + getResolvedFieldName(fieldNo) + " & "
2088: + getFieldIndex(fieldNo) + ") == 0) {\n");
2089: buf
2090: .append("\t\t\t\t\t_"
2091: + fieldNo
2092: + " = "
2093: + (isDate ? "(java.util.Date)" : "")
2094: + "cmd.stateFields["
2095: + fieldNo
2096: + "].createSCO(pm, pm.getInternalSM(owningPC), cmd.stateFields["
2097: + fieldNo + "], owningPC, _" + fieldNo
2098: + ");\n");
2099: done = true;
2100: }
2101: } else {
2102: int cat = info.category;
2103: if (cat == MDStatics.CATEGORY_EXTERNALIZED) {
2104: buf.append("\t\t\tif (_" + fieldNo + " != null) {\n");
2105: buf.append("\t\t\t\tif (("
2106: + getResolvedFieldName(fieldNo) + " & "
2107: + getFieldIndex(fieldNo) + ") == 0) {\n");
2108: buf.append("\t\t\t\t\t_" + fieldNo
2109: + " = cmd.stateFields[" + fieldNo
2110: + "].externalizer.fromExternalForm(pm, _"
2111: + fieldNo + ");\n");
2112: done = true;
2113: } else if (cat == MDStatics.CATEGORY_REF
2114: || cat == MDStatics.CATEGORY_POLYREF) {
2115: buf.append("\t\t\tif (_" + fieldNo + " != null) {\n");
2116: buf.append("\t\t\t\tif (("
2117: + getResolvedFieldName(fieldNo) + " & "
2118: + getFieldIndex(fieldNo) + ") == 0) {\n");
2119: buf.append("\t\t\t\t\t_" + fieldNo
2120: + " = pm.getObjectByIdForState((OID)_"
2121: + fieldNo + ", " + fieldNo + ", " + cmd.index
2122: + ", oid);\n");
2123: done = true;
2124: }
2125: //ignore else
2126: }
2127:
2128: if (done) {
2129: buf.append("\t\t\t\t\t" + getResolvedFieldName(fieldNo)
2130: + " |= " + getFieldIndex(fieldNo) + ";\n");
2131: buf.append("\t\t\t\t}\n");
2132: buf.append("\t\t\t\treturn _" + fieldNo + ";\n");
2133: buf.append("\t\t\t} else {\n");
2134: buf.append("\t\t\t\treturn null;\n");
2135: buf.append("\t\t\t}\n");
2136: } else {
2137: buf.append("\t\t\t" + getResolvedFieldName(fieldNo)
2138: + " |= " + getFieldIndex(fieldNo) + ";\n");
2139: buf.append("\t\t\treturn _" + fieldNo + ";\n");
2140: }
2141: }
2142:
2143: protected void addGetResolvableObjectFieldAbs() {
2144: StringBuffer buf = new StringBuffer();
2145: // public final Object getObjectFieldAbs(int absFieldNo, PersistenceCapable owningPC, VersantPersistenceManagerImp sm, OID oid) {
2146: // return getObjectField(cmd.absToRel[absFieldNo], owningPC, sm, oid);
2147: // }
2148: buf
2149: .append("\n\tpublic final Object getObjectFieldAbs(int absFieldNo, PersistenceCapable owningPC, PersistenceContext sm, OID oid) {\n");
2150: buf
2151: .append("\t\treturn getObjectField(cmd.absToRel[absFieldNo], owningPC, sm, oid);\n");
2152: buf.append("\t}\n");
2153: spec.addMethod(buf.toString());
2154: }
2155:
2156: protected boolean isOID(FieldMetaData info) {
2157: if (info.category == MDStatics.CATEGORY_REF) {
2158: return true;
2159: }
2160: return false;
2161: }
2162:
2163: protected boolean isObject(FieldMetaData fmd) {
2164: return isOID(fmd) || isCollection(fmd) || isMap(fmd)
2165: || isArray(fmd) || isPolyRef(fmd)
2166: || isExternalized(fmd);
2167: }
2168:
2169: protected boolean isExternalized(FieldMetaData fmd) {
2170: if (fmd.category == MDStatics.CATEGORY_EXTERNALIZED) {
2171: return true;
2172: }
2173: return false;
2174: }
2175:
2176: protected void addGetInternalObjectField() {
2177: StringBuffer buf = new StringBuffer();
2178:
2179: /*public final Object getInternalObjectField(int field) {
2180: if (field == 2) {
2181: return _2;
2182: } else {
2183: throw new JDOFatalInternalException("The specified Object field was not found.");
2184: }
2185: }*/
2186:
2187: buf
2188: .append("\n\tpublic final Object getInternalObjectField(int field) {\n");
2189: List fields = getObjectFieldsMetaData();
2190: if (fields.isEmpty()) {
2191: buf
2192: .append("\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
2193: } else if (fields.size() == 1) {
2194: for (Iterator singelIter = fields.iterator(); singelIter
2195: .hasNext();) {
2196: int fieldNo = getFieldNo((FieldMetaData) singelIter
2197: .next());
2198: buf.append("\t\tif (field == " + fieldNo + ") {\n");
2199: buf.append("\t\t\treturn _" + fieldNo + ";\n");
2200: buf.append("\t\t} else {\n");
2201: buf
2202: .append("\t\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
2203: buf.append("\t\t}\n");
2204: }
2205: } else {
2206: buf.append("\t\tswitch (field) {\n");
2207: for (Iterator fieldIter = fields.iterator(); fieldIter
2208: .hasNext();) {
2209: int fieldNo = getFieldNo((FieldMetaData) fieldIter
2210: .next());
2211: buf.append("\t\t\tcase " + fieldNo + ":\n");
2212: buf.append("\t\t\t\treturn _" + fieldNo + ";\n\n");
2213: }
2214: // Do default
2215: buf.append("\t\t\tdefault:\n");
2216: buf
2217: .append("\t\t\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
2218: buf.append("\t\t}\n");
2219: }
2220: buf.append("\t}\n");
2221: spec.addMethod(buf.toString());
2222: }
2223:
2224: protected void addGetInternalObjectFieldAbs() {
2225: StringBuffer buf = new StringBuffer();
2226:
2227: // public final Object getInternalObjectFieldAbs(int absField) {
2228: // switch (absField) {
2229: // case 0: // '\0'
2230: // return _0;
2231: // case 4: // '\004'
2232: // return _5;
2233: // default:
2234: // throw new JDOFatalInternalException("The specified Object field was not found.");
2235: // }
2236: // }
2237:
2238: buf
2239: .append("\n\tpublic final Object getInternalObjectFieldAbs(int absField) {\n");
2240: List fields = getObjectFieldsMetaDataAbs();
2241: if (fields.isEmpty()) {
2242: buf
2243: .append("\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
2244: } else if (fields.size() == 1) {
2245: for (Iterator singelIter = fields.iterator(); singelIter
2246: .hasNext();) {
2247: FieldMetaData info = (FieldMetaData) singelIter.next();
2248: int fieldNo = getFieldNo(info);
2249: buf.append("\t\tif (absField == " + getAbsFieldNo(info)
2250: + ") {\n");
2251: buf.append("\t\t\treturn _" + fieldNo + ";\n");
2252: buf.append("\t\t} else {\n");
2253: buf
2254: .append("\t\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
2255: buf.append("\t\t}\n");
2256: }
2257: } else {
2258: buf.append("\t\tswitch (absField) {\n");
2259: for (Iterator fieldIter = fields.iterator(); fieldIter
2260: .hasNext();) {
2261: FieldMetaData info = (FieldMetaData) fieldIter.next();
2262: int fieldNo = getFieldNo(info);
2263: buf.append("\t\t\tcase " + getAbsFieldNo(info) + ":\n");
2264: buf.append("\t\t\t\treturn _" + fieldNo + ";\n\n");
2265: }
2266: // Do default
2267: buf.append("\t\t\tdefault:\n");
2268: buf
2269: .append("\t\t\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
2270: buf.append("\t\t}\n");
2271: }
2272: buf.append("\t}\n");
2273: spec.addMethod(buf.toString());
2274: }
2275:
2276: protected void addContainsApplicationIdentityFields() {
2277: StringBuffer buf = new StringBuffer();
2278: buf
2279: .append("\n\tpublic final boolean containsApplicationIdentityFields() {\n");
2280: buf.append("\t\treturn false;\n");
2281: buf.append("\t}\n");
2282: spec.addMethod(buf.toString());
2283: }
2284:
2285: protected abstract void addContainsValidAppIdFields();
2286:
2287: protected void addUpdateFrom() {
2288: StringBuffer buf = new StringBuffer();
2289: // public final void updateFrom(State state) {
2290: // HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff other = (HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff) state;
2291: // int otherFilled = other.filled0;
2292: // filled0 |= otherFilled;
2293: // if ((otherFilled & 1) != 0) {
2294: // _0 = other._0;
2295: // }
2296: // if ((otherFilled & -2147483648) != 0) {
2297: // _31 = other._31;
2298: // }
2299: // otherFilled = other.filled1;
2300: // filled1 |= otherFilled;
2301: // if ((otherFilled & 1) != 0) {
2302: // _32 = other._32;
2303: // }
2304: // }
2305:
2306: buf.append("\n\tpublic final void updateFrom(State state) {\n");
2307: buf.append("\t\t" + className + " other = (" + className
2308: + ") state;\n");
2309: int num = getNumOfControlFields();
2310: for (int i = 0; i < num; i++) {
2311: if (i == 0) {
2312: buf.append("\t\tint otherFilled = other.filled0;\n");
2313: buf.append("\t\tfilled0 |= otherFilled;\n");
2314: } else {
2315: buf
2316: .append("\t\totherFilled = other.filled" + i
2317: + ";\n");
2318: buf.append("\t\tfilled" + i + " |= otherFilled;\n");
2319: }
2320: List fields = getFields(i);
2321: for (Iterator iter = fields.iterator(); iter.hasNext();) {
2322: FieldMetaData fmd = (FieldMetaData) iter.next();
2323: int fieldNo = fmd.stateFieldNo;
2324: buf.append("\t\tif ((otherFilled & "
2325: + getFieldIndex(fieldNo) + ") != 0) {\n");
2326: buf.append("\t\t\t_" + fieldNo + " = other._" + fieldNo
2327: + ";\n");
2328: buf.append("\t\t}\n");
2329: }
2330: }
2331: buf.append("\t}\n");
2332: spec.addMethod(buf.toString());
2333: }
2334:
2335: protected void addGetCopy() {
2336: StringBuffer buf = new StringBuffer();
2337:
2338: // public final State getCopy() {
2339: // HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff copy = new HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff();
2340: // copy.filled0 = filled0;
2341: // copy.filled1 = filled1;
2342: // copy.filled2 = filled2;
2343: // copy.txId = super.getTxId();
2344: // copy._0 = _0;
2345: // copy._1 = _1;
2346: // copy._2 = _2;
2347: // copy._3 = _3;
2348: // copy._4 = _4;
2349: // copy._5 = _5;
2350: // copy._6 = _6;
2351: // return copy;
2352: // }
2353: // copy.txId = super.getTxId();
2354: buf.append("\n\tpublic final State getCopy() {\n");
2355: buf.append("\t\t" + className + " copy = new " + className
2356: + "();\n");
2357: int contNum = getNumOfControlFields();
2358: for (int i = 0; i < contNum; i++) {
2359: buf.append("\t\tcopy.filled" + i + " = filled" + i + ";\n");
2360: }
2361: int num = cmd.stateFields.length;
2362: for (int i = 0; i < num; i++) {
2363: buf.append("\t\tcopy._" + i + " = _" + i + ";\n");
2364: }
2365: buf.append("\t\treturn copy;\n");
2366: buf.append("\t}\n");
2367: spec.addMethod(buf.toString());
2368: }
2369:
2370: protected void addPrepare() {
2371: StringBuffer buf = new StringBuffer();
2372: buf
2373: .append("\n\tpublic void prepare(PersistenceContext pm, VersantStateManager sm) {\n");
2374: int num = cmd.stateFields.length;
2375: for (int i = 0; i < num; i++) {
2376: FieldMetaData fmd = cmd.stateFields[i];
2377: int fieldNum = fmd.stateFieldNo;
2378:
2379: boolean doIt = false;
2380: if (fmd.scoField) {
2381: if (fmd.typeCode == MDStatics.DATE) {
2382: doIt = true;
2383: } else {
2384: switch (fmd.category) {
2385: case MDStatics.CATEGORY_ARRAY:
2386: if (fmd.isElementTypePC()) {
2387: doIt = true;
2388: }
2389: break;
2390: case MDStatics.CATEGORY_COLLECTION:
2391: case MDStatics.CATEGORY_MAP:
2392: doIt = true;
2393: break;
2394: default:
2395: throw BindingSupportImpl
2396: .getInstance()
2397: .internal(
2398: "No logic defined for field type "
2399: + MDStaticUtils
2400: .toSimpleName(fmd.typeCode)
2401: + " field name = "
2402: + fmd.name);
2403: }
2404: }
2405: } else {
2406: int cat = fmd.category;
2407: if (cat == MDStatics.CATEGORY_EXTERNALIZED) {
2408: doIt = true;
2409: } else if (cat == MDStatics.CATEGORY_REF
2410: || cat == MDStatics.CATEGORY_POLYREF) {
2411: doIt = true;
2412: }
2413: }
2414:
2415: if (doIt) { // We are not interested in any others
2416: boolean isDate = fmd.typeCode == MDStatics.DATE;
2417: if (fmd.scoField) {
2418: if (isDate) {
2419: buf.append("\t\tif (("
2420: + getFilledFieldName(fieldNum) + " & "
2421: + getFieldIndex(fieldNum)
2422: + ") != 0 && _" + fieldNum
2423: + " != null) {\n");
2424: buf.append("\t\t\t_" + fieldNum
2425: + " = StateUtil.getPValueForSCO(_"
2426: + fieldNum + ");\n");
2427: buf.append("\t\t}\n");
2428: } else {
2429: switch (fmd.category) {
2430: case MDStatics.CATEGORY_ARRAY:
2431: buf.append("\t\tif (("
2432: + getFilledFieldName(fieldNum)
2433: + " & " + getFieldIndex(fieldNum)
2434: + ") != 0 && _" + fieldNum
2435: + " != null && !(_" + fieldNum
2436: + " instanceof OID[])) {\n");
2437: buf
2438: .append("\t\t\t_"
2439: + fieldNum
2440: + " = resolveArrayValues((Object[]) _"
2441: + fieldNum + ", pm);\n");
2442: buf.append("\t\t}\n");
2443: break;
2444: case MDStatics.CATEGORY_COLLECTION:
2445: buf.append("\t\tif (("
2446: + getFilledFieldName(fieldNum)
2447: + " & " + getFieldIndex(fieldNum)
2448: + ") != 0 && _" + fieldNum
2449: + " != null && !(_" + fieldNum
2450: + " instanceof OID[])) {\n");
2451: buf
2452: .append("\t\t\t_"
2453: + fieldNum
2454: + " = StateUtil.getPValueForSCO((java.util.Collection)_"
2455: + fieldNum
2456: + ", pm, sm, cmd.stateFields["
2457: + fieldNum + "]);\n");
2458: buf.append("\t\t}\n");
2459: break;
2460: case MDStatics.CATEGORY_MAP:
2461: buf.append("\t\tif (("
2462: + getFilledFieldName(fieldNum)
2463: + " & " + getFieldIndex(fieldNum)
2464: + ") != 0 && _" + fieldNum
2465: + " != null && !(_" + fieldNum
2466: + " instanceof "
2467: + MapEntries.class.getName()
2468: + ")) {\n");
2469: buf
2470: .append("\t\t\t_"
2471: + fieldNum
2472: + " = StateUtil.getPValueForSCO((java.util.Map)_"
2473: + fieldNum
2474: + ", pm, cmd.stateFields["
2475: + fieldNum + "]);\n");
2476: buf.append("\t\t}\n");
2477: break;
2478: case MDStatics.CATEGORY_TRANSACTIONAL:
2479: break;
2480: default:
2481: throw BindingSupportImpl
2482: .getInstance()
2483: .internal(
2484: "No logic defined for field type "
2485: + MDStaticUtils
2486: .toSimpleName(fmd.typeCode)
2487: + " field name = "
2488: + fmd.name);
2489: }
2490: }
2491: } else {
2492: int cat = fmd.category;
2493: if (cat == MDStatics.CATEGORY_EXTERNALIZED) {
2494: buf.append("\t\tif (("
2495: + getFilledFieldName(fieldNum) + " & "
2496: + getFieldIndex(fieldNum)
2497: + ") != 0 && _" + fieldNum
2498: + " != null) {\n");
2499: buf
2500: .append("\t\t\t_"
2501: + fieldNum
2502: + " = cmd.stateFields["
2503: + fieldNum
2504: + "].externalizer.toExternalForm(pm.getPersistenceManager() , _"
2505: + fieldNum + ");\n");
2506: buf.append("\t\t}\n");
2507: } else if (cat == MDStatics.CATEGORY_REF
2508: || cat == MDStatics.CATEGORY_POLYREF) {
2509: if (fmd.embedded) {
2510: buf.append("\t\t_" + fieldNum
2511: + " = null;\n");
2512: } else {
2513: buf
2514: .append("\t\tif (("
2515: + getFilledFieldName(fieldNum)
2516: + " & "
2517: + getFieldIndex(fieldNum)
2518: + ") != 0 && (_"
2519: + fieldNum
2520: + " instanceof PersistenceCapable)) {\n");
2521: buf
2522: .append("\t\t\t_"
2523: + fieldNum
2524: + " = StateUtil.getPValueForRef((PersistenceCapable)_"
2525: + fieldNum + ", pm);\n");
2526: buf.append("\t\t}\n");
2527: }
2528: }
2529: }
2530: }
2531: }
2532: buf.append("\t}\n");
2533: spec.addMethod(buf.toString());
2534: }
2535:
2536: protected void addCopyFieldsForOptimisticLocking() {
2537: StringBuffer buf = new StringBuffer();
2538:
2539: // public final void copyFieldsForOptimisticLocking(State state, VersantPersistenceManagerImp sm) {
2540: // HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_Person s = (HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_Person)state;
2541: // int toCheck = ~filled0 & s.filled0;
2542: // filled0 |= toCheck & 8388737;
2543: // if ((toCheck & 1) != 0) {
2544: // _0 = s._0;
2545: // }
2546: // if ((toCheck & 2) != 0 && s._1 != null) {
2547: // if ((s.resolved0 & 2) != 0) {
2548: // _1 = sm.getInternalOID((PersistenceCapable)s._1);
2549: // } else {
2550: // _1 = s._1;
2551: // }
2552: // filled0 |= 2;
2553: // }
2554: // if ((toCheck & 4) != 0 && s._2 != null) {
2555: // if ((s.resolved0 & 4) != 0) {
2556: // _2 = (Date)s._2.clone();
2557: // } else {
2558: // _2 = s._2;
2559: // }
2560: // filled0 |= 4;
2561: // }
2562: // if ((toCheck & 256) != 0 && s._8 != null) {
2563: // _8 = s._8;
2564: // filled0 |= 256;
2565: // }
2566: // if ((toCheck & 8388608) != 0) {
2567: // _23 = s._23;
2568: // }
2569: // }
2570: buf
2571: .append("\n\tpublic final void copyFieldsForOptimisticLocking(State state, VersantPersistenceManagerImp sm) {\n");
2572: buf.append("\t\t" + className + " s = (" + className
2573: + ")state;\n");
2574:
2575: int num = getNumOfControlFields();
2576: for (int i = 0; i < num; i++) {
2577: if (i == 0) {
2578: buf.append("\t\tint toCheck = ~filled" + i
2579: + " & s.filled" + i + ";\n");
2580: } else {
2581: buf.append("\t\ttoCheck = ~filled" + i + " & s.filled"
2582: + i + ";\n");
2583: }
2584: buf.append("\t\tfilled" + i + " |= toCheck & "
2585: + getPrimativeHashForIndex(i) + ";\n");
2586: List fields = getFields(i);
2587: for (Iterator iter = fields.iterator(); iter.hasNext();) {
2588: FieldMetaData fmd = (FieldMetaData) iter.next();
2589: int fieldNo = fmd.stateFieldNo;
2590: boolean isPrimative = fmd.type.isPrimitive();
2591: if (isPrimative) {
2592: buf.append("\t\tif ((toCheck & "
2593: + getFieldIndex(fieldNo) + ") != 0) {\n");
2594: buf.append("\t\t\t_" + fieldNo + " = s._" + fieldNo
2595: + ";\n");
2596: buf.append("\t\t}\n");
2597: } else {
2598: buf.append("\t\tif ((toCheck & "
2599: + getFieldIndex(fieldNo) + ") != 0 && s._"
2600: + fieldNo + " != null) {\n");
2601: if (fmd.typeCode == MDStatics.DATE) { // its a date
2602: buf.append("\t\t\tif ((s."
2603: + getResolvedFieldName(fieldNo) + " & "
2604: + getFieldIndex(fieldNo)
2605: + ") != 0) {\n");
2606: buf.append("\t\t\t\t_" + fieldNo
2607: + " = (java.util.Date)s._" + fieldNo
2608: + ".clone();\n");
2609: buf.append("\t\t\t} else {\n");
2610: buf.append("\t\t\t\t_" + fieldNo + " = s._"
2611: + fieldNo + ";\n");
2612: buf.append("\t\t\t}\n");
2613: buf.append("\t\t\t"
2614: + getFilledFieldName(fieldNo) + " |= "
2615: + getFieldIndex(fieldNo) + ";\n");
2616: } else if (fmd.category == MDStatics.CATEGORY_REF
2617: || fmd.category == MDStatics.CATEGORY_POLYREF) { // its a oid
2618: buf.append("\t\t\tif ((s."
2619: + getResolvedFieldName(fieldNo) + " & "
2620: + getFieldIndex(fieldNo)
2621: + ") != 0) {\n");
2622: buf
2623: .append("\t\t\t\t_"
2624: + fieldNo
2625: + " = sm.getInternalOID((PersistenceCapable)s._"
2626: + fieldNo + ");\n");
2627: buf.append("\t\t\t} else {\n");
2628: buf.append("\t\t\t\t_" + fieldNo + " = s._"
2629: + fieldNo + ";\n");
2630: buf.append("\t\t\t}\n");
2631: buf.append("\t\t\t"
2632: + getFilledFieldName(fieldNo) + " |= "
2633: + getFieldIndex(fieldNo) + ";\n");
2634:
2635: } else { // its a Object
2636: buf.append("\t\t\t_" + fieldNo + " = s._"
2637: + fieldNo + ";\n");
2638: buf.append("\t\t\t"
2639: + getFilledFieldName(fieldNo) + " |= "
2640: + getFieldIndex(fieldNo) + ";\n");
2641: }
2642: buf.append("\t\t}\n");
2643: }
2644: }
2645: }
2646: buf.append("\t}\n");
2647: spec.addMethod(buf.toString());
2648: }
2649:
2650: protected void addGetFieldNos() {
2651: StringBuffer buf = new StringBuffer();
2652: /*
2653:
2654: public final int getFieldNos(int buf[]) {
2655: int c = 0;
2656: int filled = filled0;
2657: if ((filled & 1) != 0) {
2658: buf[c++] = 0;
2659: }
2660: if ((filled & -2147483648) != 0) {
2661: buf[c++] = 31;
2662: }
2663: filled = filled1;
2664: if ((filled & 1) != 0) {
2665: buf[c++] = 32;
2666: }
2667: if ((filled & 2) != 0) {
2668: buf[c++] = 33;
2669: }
2670: return c;
2671: }
2672: */
2673: buf.append("\n\tpublic final int getFieldNos(int buf[]) {\n");
2674: buf.append("\t\tint c = 0;\n");
2675: int num = getNumOfControlFields();
2676: for (int i = 0; i < num; i++) {
2677: if (i == 0) {
2678: buf.append("\t\tint filled = filled0;\n");
2679: } else {
2680: buf.append("\t\tfilled = filled" + i + ";\n");
2681: }
2682: List fields = getFields(i);
2683: for (Iterator iter = fields.iterator(); iter.hasNext();) {
2684: FieldMetaData fmd = (FieldMetaData) iter.next();
2685: int fieldNo = fmd.stateFieldNo;
2686: buf.append("\t\tif ((filled & "
2687: + getFieldIndex(fieldNo) + ") != 0) {\n");
2688: buf.append("\t\t\tbuf[c++] = " + fieldNo + ";\n");
2689: buf.append("\t\t}\n");
2690: }
2691: }
2692: buf.append("\t\treturn c;\n");
2693: buf.append("\t}\n");
2694: spec.addMethod(buf.toString());
2695: }
2696:
2697: protected void addUpdateNonFilled() {
2698: StringBuffer buf = new StringBuffer();
2699: // public final void updateNonFilled(State state) {
2700: // HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff s = (HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff) state;
2701: // int toCheck = ~filled0 & s.filled0;
2702: // filled0 |= toCheck;
2703: // if ((toCheck & 1) != 0) {
2704: // _0 = s._0;
2705: // }
2706: //
2707: // if ((toCheck & 1073741824) != 0) {
2708: // _30 = s._30;
2709: // }
2710: // if ((toCheck & -2147483648) != 0) {
2711: // _31 = s._31;
2712: // }
2713: // toCheck = ~filled1 & s.filled1;
2714: // filled1 |= toCheck;
2715: // if ((toCheck & 1) != 0) {
2716: // _32 = s._32;
2717: // }
2718: // if ((toCheck & 2) != 0) {
2719: // _33 = s._33;
2720: // }
2721: // if ((toCheck & 4) != 0) {
2722: // _34 = s._34;
2723: // }
2724: // }
2725:
2726: buf
2727: .append("\n\tpublic final void updateNonFilled(State state) {\n");
2728: buf.append("\t\t" + className + " s = (" + className
2729: + ") state;\n");
2730: int num = getNumOfControlFields();
2731: for (int i = 0; i < num; i++) {
2732: if (i == 0) {
2733: buf.append("\t\tint toCheck = ~filled0 & s.filled0;\n");
2734: buf.append("\t\tfilled0 |= toCheck;\n");
2735: } else {
2736: buf.append("\t\ttoCheck = ~filled" + i + " & s.filled"
2737: + i + ";\n");
2738: buf.append("\t\tfilled" + i + " |= toCheck;\n");
2739: }
2740: List fields = getFields(i);
2741: for (Iterator iter = fields.iterator(); iter.hasNext();) {
2742: FieldMetaData fmd = (FieldMetaData) iter.next();
2743: int fieldNo = fmd.stateFieldNo;
2744: String fieldName = getFieldName(fieldNo);
2745: buf.append("\t\tif ((toCheck & "
2746: + getFieldIndex(fieldNo) + ") != 0) {\n");
2747: buf.append("\t\t\t" + fieldName + " = s." + fieldName
2748: + ";\n");
2749: buf.append("\t\t}\n");
2750: }
2751:
2752: }
2753: buf.append("\t}\n");
2754: spec.addMethod(buf.toString());
2755: }
2756:
2757: protected void addCopyOptimisticLockingField() {
2758: StringBuffer buf = new StringBuffer();
2759:
2760: // public void copyOptimisticLockingField(State state) {
2761: // GenericState gState = (GenericState) state;
2762: // FieldMetaData optimisticLockingField = cmd.optimisticLockingField;
2763: // if (optimisticLockingField == null) return;
2764: // if (gState.filled[optimisticLockingField.stateFieldNo]) {
2765: // data[optimisticLockingField.stateFieldNo] = gState.data[optimisticLockingField.stateFieldNo];
2766: // filled[optimisticLockingField.stateFieldNo] = true;
2767: // }
2768: // }
2769:
2770: buf
2771: .append("\n\tpublic final void copyOptimisticLockingField(State state) {\n");
2772: if (cmd.optimisticLockingField == null) {
2773: buf.append("\t\treturn;\n");
2774: } else {
2775: buf.append("\t\t" + className + " gState = (" + className
2776: + ")state;\n");
2777: int fieldNo = cmd.optimisticLockingField.stateFieldNo;
2778: String filled = getFilledFieldName(fieldNo);
2779: int index = getFieldIndex(fieldNo);
2780: buf.append("\t\tif ((gState." + filled + " & " + index
2781: + ") != 0) {\n");
2782: buf.append("\t\t\t_" + fieldNo + " = gState._" + fieldNo
2783: + ";\n");
2784: buf.append("\t\t\t" + filled + " |= " + index + ";\n");
2785: buf.append("\t\t}\n");
2786: }
2787: buf.append("\t}\n");
2788: spec.addMethod(buf.toString());
2789:
2790: }
2791:
2792: protected void addClearNonFilled() {
2793: StringBuffer buf = new StringBuffer();
2794: // public final void clearNonFilled(State state) {
2795: // HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff s = (HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff) state;
2796: // int filled = filled0;
2797: // filled0 = filled & 0 | filled & s.filled0;
2798: // filled = filled1;
2799: // filled1 = filled & 0 | filled & s.filled1;
2800: // filled = filled2;
2801: // filled2 = filled & 32768 | filled & s.filled2;
2802: // }
2803:
2804: buf
2805: .append("\n\tpublic final void clearNonFilled(State state) {\n");
2806: buf.append("\t\t" + className + " s = (" + className
2807: + ") state;\n");
2808: int num = getNumOfControlFields();
2809: // setup the mask, if a field is = MDStatics.AUTOSET_NO, the index will be 0 else 1.
2810: int[] masks = new int[num];
2811: int lenght = cmd.stateFields.length;
2812: for (int i = 0; i < lenght; i++) {
2813: if (cmd.stateFields[i].autoSet != MDStatics.AUTOSET_NO) {
2814: int fieldNum = cmd.stateFields[i].stateFieldNo;
2815: masks[getLocalVarIndex(0, fieldNum)] += getFieldIndex(fieldNum);
2816: }
2817: }
2818:
2819: for (int i = 0; i < num; i++) {
2820: if (i == 0) {
2821: buf.append("\t\tint filled = filled0;\n");
2822: } else {
2823: buf.append("\t\tfilled = filled" + i + ";\n");
2824: }
2825: buf.append("\t\tfilled" + i + " = filled & " + masks[i]
2826: + " | filled & s.filled" + i + ";\n");
2827: }
2828: buf.append("\t}\n");
2829: spec.addMethod(buf.toString());
2830:
2831: }
2832:
2833: protected void addMakeClean() {
2834: StringBuffer buf = new StringBuffer();
2835: // public final void makeClean() {
2836: // dirtyFields0 = 0;
2837: // dirtyFields1 = 0;
2838: // dirtyFields2 = 0;
2839: // }
2840: buf.append("\n\tpublic final void makeClean() {\n");
2841: int num = getNumOfControlFields();
2842: for (int i = 0; i < num; i++) {
2843: buf.append("\t\tdirtyFields" + i + " = 0;\n");
2844: }
2845: buf.append("\t}\n");
2846: spec.addMethod(buf.toString());
2847: }
2848:
2849: protected void addIsResolvedForClient() {
2850: StringBuffer buf = new StringBuffer();
2851: // public final boolean isResolvedForClient(int stateFieldNo) {
2852: // if (stateFieldNo < 32) {
2853: // return (resolved0 & 1 << stateFieldNo) != 0;
2854: // }
2855: // if (stateFieldNo < 64) {
2856: // return (resolved1 & 1 << stateFieldNo ) != 0;
2857: // }
2858: // if (stateFieldNo < 96) {
2859: // return (resolved2 & 1 << stateFieldNo) != 0;
2860: // }
2861: // return false;
2862: // }
2863: buf
2864: .append("\n\tpublic final boolean isResolvedForClient(int stateFieldNo) {\n");
2865: int num = getNumOfControlFields();
2866: if (num == 1) {
2867: buf
2868: .append("\t\treturn (resolved0 & 1 << stateFieldNo) != 0;\n");
2869: } else {
2870: for (int i = 0; i < num; i++) {
2871: buf.append("\t\tif (stateFieldNo < " + ((32 * i) + 32)
2872: + ") {\n");
2873: buf.append("\t\t\treturn (resolved" + i
2874: + " & 1 << stateFieldNo) != 0;\n");
2875: buf.append("\t\t}\n");
2876: }
2877: buf.append("\t\treturn false;\n");
2878: }
2879: buf.append("\t}\n");
2880: spec.addMethod(buf.toString());
2881: }
2882:
2883: protected void addContainsField() {
2884: StringBuffer buf = new StringBuffer();
2885:
2886: buf
2887: .append("\n\tpublic final boolean containsField(int fieldNo) {\n");
2888: int num = getNumOfControlFields();
2889: if (num == 1) {
2890: buf.append("\t\treturn (filled0 & 1 << fieldNo) != 0;\n");
2891: } else {
2892: for (int i = 0; i < num; i++) {
2893: buf.append("\t\tif (fieldNo < " + ((32 * i) + 32)
2894: + ") {\n");
2895: buf.append("\t\t\treturn (filled" + i
2896: + " & 1 << fieldNo) != 0;\n");
2897: buf.append("\t\t}\n");
2898: }
2899: buf.append("\t\treturn false;\n");
2900: }
2901: buf.append("\t}\n");
2902: spec.addMethod(buf.toString());
2903: }
2904:
2905: protected void addEqualsObject() {
2906: StringBuffer buf = new StringBuffer();
2907:
2908: /*public final boolean equals (Object object) {
2909: if (hashCode() != object.hashCode()) {
2910: return false;
2911: }
2912: if (object instanceof HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff) {
2913: HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff other = (HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff) object;
2914:
2915: if (_1 != other._1) {
2916: return false;
2917: }
2918:
2919: if (_78 != null) {
2920: if (!_78.equals(other._78)) {
2921: return false;
2922: }
2923: } else if (other._78 != null) {
2924: return false;
2925: }
2926: return true;
2927: } else {
2928: return false;
2929: }
2930: }*/
2931:
2932: buf
2933: .append("\n\tpublic final boolean equals(Object object) {\n");
2934: buf.append("\t\tif (hashCode() != object.hashCode()) {\n");
2935: buf.append("\t\t\treturn false;\n");
2936: buf.append("\t\t}\n");
2937: buf.append("\t\tif (object instanceof " + className + ") {\n");
2938: buf.append("\t\t\t" + className + " other = (" + className
2939: + ") object;\n");
2940: FieldMetaData[] fields = cmd.stateFields;
2941: for (int i = 0; i < fields.length; i++) {
2942: FieldMetaData fmd = fields[i];
2943: Class classType = fmd.type;
2944: String fieldName = getFieldName(i);
2945: boolean isPrimitive = classType.isPrimitive();
2946: if (isPrimitive) {
2947: buf.append("\t\t\tif (" + fieldName + " != other."
2948: + fieldName + ") {\n");
2949: buf.append("\t\t\t\treturn false;\n");
2950: buf.append("\t\t\t}\n");
2951: } else { // this is a object and it can be null
2952: buf.append("\t\t\tif (" + fieldName + " != null) {\n");
2953: buf.append("\t\t\t\tif (!" + fieldName
2954: + ".equals(other." + fieldName + ")) {\n");
2955: buf.append("\t\t\t\t\treturn false;\n");
2956: buf.append("\t\t\t\t}\n");
2957: buf.append("\t\t\t} else if (other." + fieldName
2958: + " != null) {\n");
2959: buf.append("\t\t\t\treturn false;\n");
2960: buf.append("\t\t\t}\n");
2961: }
2962:
2963: }
2964: buf.append("\t\t\treturn true;\n");
2965: buf.append("\t\t} else {\n");
2966: buf.append("\t\t\treturn false;\n");
2967: buf.append("\t\t}\n");
2968: buf.append("\t}\n");
2969: spec.addMethod(buf.toString());
2970: }
2971:
2972: protected void addHashCode() {
2973: StringBuffer buf = new StringBuffer();
2974: // public final int hashCode() {
2975: // return 735186935 + filled0 + filled1 + filled2;
2976: // }
2977:
2978: buf.append("\n\tpublic final int hashCode() {\n");
2979: buf.append("\t\treturn " + cmd.classId);
2980: int num = getNumOfControlFields();
2981: for (int i = 0; i < num; i++) {
2982: buf.append(" + " + FILLED_FIELD_NAME + i);
2983: }
2984: buf.append(";\n");
2985: buf.append("\t}\n");
2986: spec.addMethod(buf.toString());
2987: }
2988:
2989: protected void addGetClassIndex() {
2990: StringBuffer buf = new StringBuffer();
2991: /*public final int getClassIndex() {
2992: return 48;
2993: }*/
2994:
2995: buf.append("\n\tpublic final int getClassIndex() {\n");
2996: buf.append("\t\treturn " + cmd.index + ";\n");
2997: buf.append("\t}\n");
2998: spec.addMethod(buf.toString());
2999: }
3000:
3001: protected void addIsDirtyInt() {
3002: StringBuffer buf = new StringBuffer();
3003:
3004: /* public final boolean isDirty(int fieldNo) {
3005: if (fieldNo < 32) {
3006: return (dirtyFields0 & 1 << fieldNo) != 0;
3007: }
3008: if (fieldNo < 64) {
3009: return (dirtyFields1 & 1 << fieldNo) != 0;
3010: }
3011: if (fieldNo < 96) {
3012: return (dirtyFields2 & 1 << fieldNo) != 0;
3013: } else {
3014: return false;
3015: }
3016: }*/
3017:
3018: buf.append("\n\tpublic final boolean isDirty(int fieldNo) {\n");
3019: int num = getNumOfControlFields();
3020: if (num == 1) {
3021: buf
3022: .append("\t\treturn (dirtyFields0 & 1 << fieldNo) != 0;\n");
3023: } else {
3024: for (int i = 0; i < num; i++) {
3025: buf.append("\t\tif (fieldNo < " + ((32 * i) + 32)
3026: + ") {\n");
3027: buf.append("\t\t\treturn (dirtyFields" + i
3028: + " & 1 << fieldNo) != 0;\n");
3029: buf.append("\t\t}\n");
3030: }
3031: buf.append("\t\treturn false;\n");
3032: }
3033: buf.append("\t}\n");
3034: spec.addMethod(buf.toString());
3035:
3036: }
3037:
3038: protected void addMakeDirty() {
3039: StringBuffer buf = new StringBuffer();
3040:
3041: /*public final void makeDirty(int fieldNo) {
3042: if (fieldNo < 32) {
3043: dirtyFields0 |= 1 << fieldNo;
3044: return;
3045: }
3046: if (fieldNo < 64) {
3047: dirtyFields1 |= 1 << fieldNo;
3048: return;
3049: }
3050: if (fieldNo < 96) {
3051: dirtyFields2 |= 1 << fieldNo;
3052: }
3053: }*/
3054:
3055: buf.append("\n\tpublic final void makeDirty(int fieldNo) {\n");
3056: int num = getNumOfControlFields();
3057: if (num == 1) {
3058: buf.append("\t\tdirtyFields0 |= 1 << fieldNo;\n");
3059: } else {
3060: for (int i = 0; i < num; i++) {
3061: buf.append("\t\tif (fieldNo < " + ((32 * i) + 32)
3062: + ") {\n");
3063: buf.append("\t\t\tdirtyFields" + i
3064: + " |= 1 << fieldNo;\n");
3065: buf.append("\t\t\treturn;\n");
3066: buf.append("\t\t}\n");
3067: }
3068: }
3069: buf.append("\t}\n");
3070: spec.addMethod(buf.toString());
3071: }
3072:
3073: protected void addSetFilled() {
3074: StringBuffer buf = new StringBuffer();
3075:
3076: buf.append("\n\tpublic final void setFilled(int fieldNo) {\n");
3077: int num = getNumOfControlFields();
3078: if (num == 1) {
3079: buf.append("\t\tfilled0 |= 1 << fieldNo;\n");
3080: } else {
3081: for (int i = 0; i < num; i++) {
3082: buf.append("\t\tif (fieldNo < " + ((32 * i) + 32)
3083: + ") {\n");
3084: buf.append("\t\t\tfilled" + i + " |= 1 << fieldNo;\n");
3085: buf.append("\t\t\treturn;\n");
3086: buf.append("\t\t}\n");
3087: }
3088: }
3089: buf.append("\t}\n");
3090: spec.addMethod(buf.toString());
3091:
3092: }
3093:
3094: protected void addClearFilledFlags() {
3095: StringBuffer buf = new StringBuffer();
3096: // public final void clearFilledFlags() {
3097: // filled0 = 0;
3098: // }
3099: buf.append("\n\tpublic final void clearFilledFlags() {\n");
3100: int num = getNumOfControlFields();
3101: for (int i = 0; i < num; i++) {
3102: buf.append("\t\tfilled" + i + " = 0;\n");
3103: }
3104: buf.append("\t}\n");
3105: spec.addMethod(buf.toString());
3106: }
3107:
3108: protected void addClear() {
3109: StringBuffer buf = new StringBuffer();
3110:
3111: buf.append("\n\tpublic final void clear() {\n");
3112: int num = getNumOfControlFields();
3113: for (int i = 0; i < num; i++) {
3114: buf.append("\t\t" + FILLED_FIELD_NAME + i + " = 0;\n");
3115: buf.append("\t\t" + DIRTY_FIELD_NAME + i + " = 0;\n");
3116: buf.append("\t\t" + RESOLVED_NAME + i + " = 0;\n");
3117: }
3118: List objectList = getAllRealObjectFields();
3119: for (Iterator iter = objectList.iterator(); iter.hasNext();) {
3120: FieldMetaData info = (FieldMetaData) iter.next();
3121: int fieldNo = getFieldNo(info);
3122: buf.append("\t\t_" + fieldNo + " = null;\n");
3123: }
3124: buf.append("\t}\n");
3125: spec.addMethod(buf.toString());
3126: }
3127:
3128: protected void addIsDirty() {
3129: StringBuffer buf = new StringBuffer();
3130: // public final boolean isDirty() {
3131: // return dirtyFields0 != 0 || dirtyFields1 != 0 || dirtyFields2 != 0;
3132: // }
3133: buf.append("\n\tpublic final boolean isDirty() {\n");
3134: int num = getNumOfControlFields();
3135: for (int i = 0; i < num; i++) {
3136: if (i == 0) {
3137: buf.append("\t\treturn dirtyFields0 != 0");
3138: } else {
3139: buf.append(" || dirtyFields" + i + " != 0");
3140: }
3141: }
3142: buf.append(";\n");
3143: buf.append("\t}\n");
3144: spec.addMethod(buf.toString());
3145: }
3146:
3147: protected void addCopyFields() {
3148: StringBuffer buf = new StringBuffer();
3149: buf.append("\n\tpublic final void copyFields(OID oid) {\n");
3150: buf.append("\t}\n");
3151: spec.addMethod(buf.toString());
3152: }
3153:
3154: /**
3155: * This method generates all the public void setXXXField(int field,xxx newValue)
3156: */
3157: protected void addAllSetXXXFields() {
3158: Set keys = classToSetField.keySet();
3159: for (Iterator typeIter = keys.iterator(); typeIter.hasNext();) {
3160: Class type = (Class) typeIter.next();
3161: addSetXXXField(type);
3162: }
3163: addSetObjectField();
3164: addSetObjectFieldUnresolved();
3165: }
3166:
3167: /**
3168: * This method generates all the public void setXXXFieldAbs(int absField,xxx newValue)
3169: */
3170: protected void addAllSetXXXFieldsAbs() {
3171: Set keys = classToSetFieldAbs.keySet();
3172: for (Iterator typeIter = keys.iterator(); typeIter.hasNext();) {
3173: Class type = (Class) typeIter.next();
3174: addSetXXXFieldAbs(type);
3175: }
3176: addSetObjectFieldAbs();
3177: addSetObjectFieldUnresolvedAbs();
3178: }
3179:
3180: /**
3181: * This method generates all the public void setXXXField(int field,xxx newValue)
3182: */
3183: protected void addAllSetInternalXXXFields() {
3184: Set keys = classToInternalSetField.keySet();
3185: for (Iterator typeIter = keys.iterator(); typeIter.hasNext();) {
3186: Class type = (Class) typeIter.next();
3187: addSetInternalXXXField(type);
3188: }
3189: addSetInternalObjectField();
3190: }
3191:
3192: /**
3193: * This method generates all the public void setInternalXXXFieldAbs(int absField,xxx newValue)
3194: */
3195: protected void addAllSetInternalXXXFieldsAbs() {
3196: Set keys = classToInternalSetFieldAbs.keySet();
3197: for (Iterator typeIter = keys.iterator(); typeIter.hasNext();) {
3198: Class type = (Class) typeIter.next();
3199: addSetInternalXXXFieldAbs(type);
3200: }
3201: addSetInternalObjectFieldAbs();
3202: }
3203:
3204: /**
3205: * This method generates all the public xxx getXXXField(int field)
3206: */
3207: protected void addAllGetXXXFields() {
3208: Set keys = getFieldToClass.keySet();
3209: for (Iterator typeIter = keys.iterator(); typeIter.hasNext();) {
3210: String type = (String) typeIter.next();
3211: addGetXXXField(type);
3212: }
3213: }
3214:
3215: /**
3216: * This method generates all the public xxx getXXXFieldAbs(int field)
3217: */
3218: protected void addAllGetXXXFieldsAbs() {
3219: Set keys = classToGetFieldAbs.keySet();
3220: for (Iterator typeIter = keys.iterator(); typeIter.hasNext();) {
3221: Class type = (Class) typeIter.next();
3222: addGetXXXFieldAbs(type);
3223: }
3224: }
3225:
3226: protected String getWriteMethod(int index) {
3227: int newIndex = totalNoOfFields - (index * 32);
3228: if (newIndex <= 8) {
3229: return "writeByte";
3230: } else if (newIndex <= 16) {
3231: return "writeShort";
3232: } else {
3233: return "writeInt";
3234: }
3235: }
3236:
3237: protected String getReadMethod(int index) {
3238: int newIndex = totalNoOfFields - (index * 32);
3239: if (newIndex <= 8) {
3240: return "readByte";
3241: } else if (newIndex <= 16) {
3242: return "readShort";
3243: } else {
3244: return "readInt";
3245: }
3246: }
3247:
3248: protected String getOIDName(FieldMetaData fmd) {
3249: //return ((JdbcRefField)fmd.jdbcField).targetClass.oidClassName;
3250: return fmd.typeMetaData.oidClassName;
3251: }
3252:
3253: protected void addWriteExternal() {
3254: StringBuffer buf = new StringBuffer();
3255: buf
3256: .append("\n\tpublic void writeExternal(OIDObjectOutput os) throws java.io.IOException {\n");
3257: Class bigIntegerType = java.math.BigInteger.class;
3258: boolean isBigInteger = false; // 2
3259: for (int i = 0; i < cmd.stateFields.length; i++) {
3260: FieldMetaData info = cmd.stateFields[i];
3261: if (!isExternalized(info)) {
3262: Class type = info.type;
3263: if (type.equals(bigIntegerType)) {
3264: isBigInteger = true;
3265: }
3266: }
3267: }
3268: if (isBigInteger) {
3269: buf.append("\t\tbyte bytes[] = null;\n");
3270: }
3271: int num = getNumOfControlFields();
3272: for (int i = 0; i < num; i++) {
3273: if (i == 0) {
3274: buf.append("\t\tint filled = filled0;\n");
3275: } else {
3276: buf.append("\t\tfilled = filled" + i + ";\n");
3277: }
3278: if (i == 0) {
3279: buf.append("\t\tint nullFields = getNullFields(0);\n");
3280: } else {
3281: buf.append("\t\tnullFields = getNullFields(" + i
3282: + ");\n");
3283: }
3284: buf.append("\t\tos." + getWriteMethod(i) + "(filled);\n");
3285: buf.append("\t\tos." + getWriteMethod(i)
3286: + "(nullFields);\n");
3287:
3288: List fields = getFields(i);
3289: for (Iterator iter = fields.iterator(); iter.hasNext();) {
3290: FieldMetaData info = (FieldMetaData) iter.next();
3291: int fieldNo = info.stateFieldNo;
3292: if (info.category != MDStatics.CATEGORY_TRANSACTIONAL) {
3293: // if (Debug.DEBUG) {
3294: // buf.append("\t\t\tos.writeUTF(\"begin "+ info.name +"\");\n");
3295: // }
3296: Class type = info.type;
3297: if (isExternalized(info)) {
3298: buf.append("\t\tif ((filled & "
3299: + getFieldIndex(fieldNo)
3300: + ") != 0 && (nullFields & "
3301: + getFieldIndex(fieldNo)
3302: + ") == 0) {\n");
3303: buf.append("\t\t\tSerUtils.writeObject(_"
3304: + fieldNo + ", os);\n");
3305: buf.append("\t\t}\n");
3306:
3307: } else if (info.type.isPrimitive()) {// do primative types
3308: buf.append("\t\tif ((filled & "
3309: + getFieldIndex(fieldNo)
3310: + ") != 0) {\n");
3311: buf.append("\t\t\tos."
3312: + primClassToSerWriteMethod.get(type)
3313: + "(_" + fieldNo + ");\n");
3314: buf.append("\t\t}\n");
3315: } else { // Object type i.e. can be null
3316: buf.append("\t\tif ((filled & "
3317: + getFieldIndex(fieldNo)
3318: + ") != 0 && (nullFields & "
3319: + getFieldIndex(fieldNo)
3320: + ") == 0) {\n");
3321: if (isOID(info) || isPolyRef(info)) {
3322: buf.append("\t\t\tos.write((OID)_"
3323: + fieldNo + ");\n");
3324: } else if (isCollection(info)) {
3325: buf
3326: .append("\t\t\tSerUtils.writeCollectionOrMapField(os, cmd.stateFields["
3327: + fieldNo
3328: + "], _"
3329: + fieldNo + ");\n");
3330: } else if (isMap(info)) {
3331: buf
3332: .append("\t\t\tSerUtils.writeCollectionOrMapField(os, cmd.stateFields["
3333: + fieldNo
3334: + "], _"
3335: + fieldNo + ");\n");
3336: } else if (isArray(info)) {
3337: if (isPCArray(info)) {
3338: buf
3339: .append("\t\t\tSerUtils.writeArrayField(cmd.stateFields["
3340: + fieldNo
3341: + "], os, _"
3342: + fieldNo + ");\n");
3343: } else {
3344: buf
3345: .append("\t\t\tSerUtils.writeArrayField("
3346: + info.componentTypeCode
3347: + ", os, _"
3348: + fieldNo
3349: + ");\n");
3350: }
3351: } else {
3352: if (type.equals(String.class)) {
3353: buf.append("\t\tUtils.writeLongUTF8(_"
3354: + fieldNo + ", os);\n");
3355: } else if (type
3356: .equals(java.util.Locale.class)) {
3357: buf.append("\t\t\tos.writeUTF(_"
3358: + fieldNo
3359: + ".getLanguage());\n");
3360: buf
3361: .append("\t\t\tos.writeUTF(_"
3362: + fieldNo
3363: + ".getCountry());\n");
3364: buf
3365: .append("\t\t\tos.writeUTF(_"
3366: + fieldNo
3367: + ".getVariant());\n");
3368: } else if (type
3369: .equals(java.math.BigDecimal.class)) {
3370: buf.append("\t\t\tos.writeUTF(_"
3371: + fieldNo + ".toString());\n");
3372: } else if (type
3373: .equals(java.math.BigInteger.class)) {
3374: buf.append("\t\t\tbytes = _" + fieldNo
3375: + ".toByteArray();\n");
3376: buf
3377: .append("\t\t\tos.writeInt(bytes.length);\n");
3378: buf.append("\t\t\tos.write(bytes);\n");
3379: } else if (type
3380: .equals(java.util.Date.class)) {
3381: buf.append("\t\t\tos.writeLong(_"
3382: + fieldNo + ".getTime());\n");
3383: } else if (type.equals(java.net.URL.class)) {
3384: buf.append("\t\t\tos.writeUTF(_"
3385: + fieldNo + ".toString());\n");
3386: } else if (type.equals(java.io.File.class)) {
3387: buf.append("\t\t\tos.writeUTF(_"
3388: + fieldNo + ".toString());\n");
3389: } else if (type
3390: .equals(java.sql.Timestamp.class)) {
3391: buf.append("\t\t\tos.writeLong(_"
3392: + fieldNo + ".getTime());\n");
3393: } else if (wrapperTypesToPrimative
3394: .containsKey(type)) { // wrapper
3395: buf
3396: .append("\t\t\tos."
3397: + primClassToSerWriteMethod
3398: .get(wrapperTypesToPrimative
3399: .get(type))
3400: + "(_"
3401: + fieldNo
3402: + "."
3403: + wrapperTypesToValue
3404: .get(type)
3405: + "());\n");
3406: } else {
3407: buf
3408: .append("\t\t\tSerUtils.writeObject(_"
3409: + fieldNo + ", os);\n");
3410: }
3411: }
3412: buf.append("\t\t}\n");
3413: }
3414: // if (Debug.DEBUG) {
3415: // buf.append("\t\t\tos.writeUTF(\"end "+ info.name +"\");\n");
3416: // }
3417: }
3418: }
3419: }
3420: buf.append("\t}\n");
3421: spec.addMethod(buf.toString());
3422: }
3423:
3424: protected void addExpect() {
3425: StringBuffer buf = new StringBuffer();
3426: buf
3427: .append(" private void expect(OIDObjectInput in, String s) throws java.io.IOException {\n"
3428: + " String got;\n"
3429: + " try {\n"
3430: + " got = in.readUTF();\n"
3431: + " } catch (IOException e) {\n"
3432: + " throw new RuntimeException(\"Expected '\" + s +\n"
3433: + " \"': \" + e, e);\n"
3434: + " }\n"
3435: + " if (!s.equals(got)) {\n"
3436: + " throw new RuntimeException(\"Expected '\" + s +\n"
3437: + " \"' got '\" + got + \"'\");\n"
3438: + " }\n" + " }");
3439: spec.addMethod(buf.toString());
3440: }
3441:
3442: protected void addReadExternal() {
3443: //addExpect();
3444: StringBuffer buf = new StringBuffer();
3445: buf
3446: .append("\n\tpublic void readExternal(OIDObjectInput is) throws java.lang.ClassNotFoundException, java.io.IOException {\n");
3447: Class bigIntegerType = java.math.BigInteger.class;
3448: boolean isBigInteger = false; // 2
3449: for (int i = 0; i < cmd.stateFields.length; i++) {
3450: FieldMetaData info = cmd.stateFields[i];
3451: if (!isExternalized(info)) {
3452: Class type = info.type;
3453: if (type.equals(bigIntegerType)) {
3454: isBigInteger = true;
3455: }
3456: }
3457: }
3458: if (isBigInteger) {
3459: buf.append("\t\tbyte bytes[] = null;\n");
3460: }
3461:
3462: int num = getNumOfControlFields();
3463: for (int i = 0; i < num; i++) {
3464: if (i == 0) {
3465: buf.append("\t\tint filled = filled0 = is."
3466: + getReadMethod(i) + "();\n");
3467: } else {
3468: buf.append("\t\tfilled = filled" + i + " = is."
3469: + getReadMethod(i) + "();\n");
3470: }
3471: if (i == 0) {
3472: buf.append("\t\tint nullFields = is."
3473: + getReadMethod(i) + "();\n");
3474: } else {
3475: buf.append("\t\tnullFields = is." + getReadMethod(i)
3476: + "();\n");
3477: }
3478: List fields = getFields(i);
3479: for (Iterator iter = fields.iterator(); iter.hasNext();) {
3480: FieldMetaData info = (FieldMetaData) iter.next();
3481: int fieldNo = info.stateFieldNo;
3482: if (info.category != MDStatics.CATEGORY_TRANSACTIONAL) {
3483: // if (Debug.DEBUG) {
3484: // buf.append("\t\t\texpect(is, \"begin "+ info.name +"\");\n");
3485: // }
3486: Class type = info.type;
3487: if (isExternalized(info)) {
3488: buf.append("\t\tif ((filled & "
3489: + getFieldIndex(fieldNo)
3490: + ") != 0 && (nullFields & "
3491: + getFieldIndex(fieldNo)
3492: + ") == 0) {\n");
3493: buf.append("\t\t\t_" + fieldNo
3494: + " = SerUtils.readObject(is);\n");
3495: buf.append("\t\t}\n");
3496: } else if (type.isPrimitive()) {// do primative types
3497: buf.append("\t\tif ((filled & "
3498: + getFieldIndex(fieldNo)
3499: + ") != 0) {\n");
3500: buf.append("\t\t\t_" + fieldNo + " = is."
3501: + primClassToSerReadMethod.get(type)
3502: + "();\n");
3503: buf.append("\t\t}\n");
3504: } else { // Object type i.e. can be null
3505: buf.append("\t\tif ((filled & "
3506: + getFieldIndex(fieldNo)
3507: + ") != 0 && (nullFields & "
3508: + getFieldIndex(fieldNo)
3509: + ") == 0) {\n");
3510:
3511: // do stuff here
3512: if (isOID(info) || isPolyRef(info)) {
3513: buf.append("\t\t\t_" + fieldNo
3514: + " = is.readOID();\n");
3515: } else if (isCollection(info)) {
3516: buf
3517: .append("\t\t\t_"
3518: + fieldNo
3519: + " = SerUtils.readCollectionOrMapField(is, cmd.stateFields["
3520: + fieldNo + "]);\n");
3521: } else if (isMap(info)) {
3522: buf
3523: .append("\t\t\t_"
3524: + fieldNo
3525: + " = SerUtils.readCollectionOrMapField(is, cmd.stateFields["
3526: + fieldNo + "]);\n");
3527: } else if (isArray(info)) {
3528: if (isPCArray(info)) {
3529: buf
3530: .append("\t\t\t_"
3531: + fieldNo
3532: + " = SerUtils.readArrayField(cmd.stateFields["
3533: + fieldNo + "], is);\n");
3534: } else {
3535: buf.append("\t\t\t_" + fieldNo
3536: + " = SerUtils.readArrayField("
3537: + info.componentTypeCode
3538: + ", is);\n");
3539: }
3540: } else {
3541: if (type.equals(String.class)) {
3542: buf
3543: .append("\t\t\t_"
3544: + fieldNo
3545: + " = Utils.readLongUTF8(is);\n");
3546: } else if (type
3547: .equals(java.util.Locale.class)) {
3548: buf
3549: .append("\t\t\t_"
3550: + fieldNo
3551: + " = new java.util.Locale(is.readUTF(), is.readUTF(), is.readUTF());\n");
3552: } else if (type
3553: .equals(java.math.BigDecimal.class)) {
3554: buf
3555: .append("\t\t\t_"
3556: + fieldNo
3557: + " = new java.math.BigDecimal(is.readUTF());\n");
3558: } else if (type
3559: .equals(java.math.BigInteger.class)) {
3560: buf
3561: .append("\t\t\tbytes = new byte[is.readInt()];\n");
3562: buf
3563: .append("\t\t\tis.readFully(bytes);\n");
3564: buf
3565: .append("\t\t\t_"
3566: + fieldNo
3567: + " = new java.math.BigInteger(bytes);\n");
3568: } else if (type
3569: .equals(java.util.Date.class)) {
3570: buf
3571: .append("\t\t\t_"
3572: + fieldNo
3573: + " = new java.util.Date(is.readLong());\n");
3574: } else if (type.equals(java.net.URL.class)) {
3575: buf
3576: .append("\t\t\t_"
3577: + fieldNo
3578: + " = new java.net.URL(is.readUTF());\n");
3579: } else if (type.equals(java.io.File.class)) {
3580: buf
3581: .append("\t\t\t_"
3582: + fieldNo
3583: + " = new java.io.File(is.readUTF());\n");
3584: } else if (type
3585: .equals(java.sql.Timestamp.class)) {
3586: buf
3587: .append("\t\t\t_"
3588: + fieldNo
3589: + " = new java.sql.Timestamp(is.readLong());\n");
3590: } else if (wrapperTypesToPrimative
3591: .containsKey(type)) { // wrapper
3592: buf
3593: .append("\t\t_"
3594: + fieldNo
3595: + " = new "
3596: + type.getName()
3597: + "(is."
3598: + primClassToSerReadMethod
3599: .get(wrapperTypesToPrimative
3600: .get(type))
3601: + "());\n");
3602: } else {
3603: buf
3604: .append("\t\t\t_"
3605: + fieldNo
3606: + " = ("
3607: + type.getName()
3608: + ")SerUtils.readObject(is);\n");
3609:
3610: }
3611: }
3612: buf.append("\t\t}\n");
3613: }
3614: // if (Debug.DEBUG) {
3615: // buf.append("\t\t\texpect(is, \"end "+ info.name +"\");\n");
3616: // }
3617: }
3618: }
3619: }
3620: buf.append("\t}\n");
3621: spec.addMethod(buf.toString());
3622: }
3623:
3624: /**
3625: * Add's a default constructor that calls the State super class
3626: * this constructor is needed so that we can get an instance from the class with class.newInstance()
3627: */
3628: protected void addConstructor() {
3629: StringBuffer buf = new StringBuffer();
3630: buf.append("\n\tpublic ");
3631: buf.append(className);
3632: buf.append("(){\n\t}\n");
3633: spec.addMethod(buf.toString());
3634: }
3635:
3636: /**
3637: * This method return's a new instance of the class, it is used after we called class.newInstance(),
3638: * the reason for this method is that class.newInstance() is +/- 15 time slower than creating the
3639: * class the normal way.
3640: * So if we do not have a instance class.newInstance() will be called, after that newInstance() will
3641: * be called on the instance, for fast object creation.
3642: */
3643: protected void addNewInstance() {
3644: StringBuffer buf = new StringBuffer();
3645:
3646: /*
3647: public final State newInstance() {
3648: return new HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_Assembly();
3649: }
3650: */
3651: buf.append("\n\tpublic final State newInstance() {\n");
3652: buf.append("\t\treturn new ");
3653: buf.append(className);
3654: buf.append("();\n\t}\n");
3655: spec.addMethod(buf.toString());
3656: }
3657:
3658: /**
3659: * Add all PC fields in the hier to state and
3660: * private boolean isDirty;
3661: * private boolean[] dirtyFields = new boolean[20];
3662: * private boolean[] filled = new boolean[20];
3663: */
3664: protected void addFields() {
3665: spec
3666: .addField("public static " + CLASS_META_DATA_CLASS
3667: + " cmd");
3668: int num = getNumOfControlFields();
3669: for (int i = 0; i < num; i++) {
3670: spec.addField("public int " + FILLED_FIELD_NAME + i);
3671: spec.addField("public int " + DIRTY_FIELD_NAME + i);
3672: spec.addField("public int " + RESOLVED_NAME + i);
3673: }
3674: FieldMetaData[] fields = cmd.stateFields;
3675: for (int i = 0; i < fields.length; i++) {
3676: if (isObject(fields[i])) { // OID
3677: spec.addField("public Object " + getFieldName(i));
3678: } else {
3679: spec.addField("public " + fields[i].type.getName()
3680: + " " + getFieldName(i));
3681: }
3682: }
3683: }
3684:
3685: /**
3686: * @param type the type of the fields we are looking for i.e Type.INT
3687: * @return List list of FieldInfo objects for the specified type
3688: */
3689: protected List getFields(Class type) {
3690: ArrayList list = new ArrayList();
3691: FieldMetaData[] fields = cmd.stateFields;
3692: for (int i = 0; i < fields.length; i++) {
3693: FieldMetaData field = fields[i];
3694: if (field.type.equals(type)) {
3695: list.add(field);
3696: }
3697: }
3698: return list;
3699: }
3700:
3701: /**
3702: * @param type the type of the fields we are looking for i.e Type.INT
3703: * @return List list of FieldInfo objects for the specified type
3704: */
3705:
3706: protected List getFieldsAbs(Class type) {
3707: ArrayList list = new ArrayList();
3708: FieldMetaData[] fields = cmd.stateFields;
3709: for (int i = 0; i < fields.length; i++) {
3710: FieldMetaData field = fields[i];
3711: if (field.type.equals(type)) {
3712: if (field.managedFieldNo != -1) {
3713: list.add(field);
3714: }
3715: }
3716: }
3717: return list;
3718: }
3719:
3720: /**
3721: * @return List list of FieldInfo objects that are not primitive types or String's.
3722: */
3723: protected List getObjectFields() { // excluding String
3724: ArrayList list = new ArrayList();
3725: FieldMetaData[] fields = cmd.stateFields;
3726: for (int i = 0; i < fields.length; i++) {
3727: FieldMetaData field = fields[i];
3728: if (!getFieldToClass.containsValue(field.type)) {
3729: list.add(field);
3730: }
3731: }
3732: return list;
3733: }
3734:
3735: /**
3736: * @return List list of FieldInfo objects that are not primitive types or String's.
3737: */
3738: protected List getObjectFieldsAbs() { // excluding String
3739: ArrayList list = new ArrayList();
3740: FieldMetaData[] fields = cmd.stateFields;
3741: for (int i = 0; i < fields.length; i++) {
3742: FieldMetaData field = fields[i];
3743: if (!getFieldToClass.containsValue(field.type)) {
3744: if (field.managedFieldNo != -1) {
3745: list.add(field);
3746: }
3747: }
3748: }
3749: return list;
3750: }
3751:
3752: /**
3753: * @return List list of FieldInfo objects that are not primitive types or String's.
3754: */
3755: protected List getObjectFieldsMetaData() { // excluding String
3756: ArrayList list = new ArrayList();
3757: FieldMetaData[] fields = cmd.stateFields;
3758: for (int i = 0; i < fields.length; i++) {
3759: FieldMetaData field = fields[i];
3760: if (!nonObjectClassTypeList.contains(field.type)) {
3761: list.add(field);
3762: }
3763: }
3764: return list;
3765: }
3766:
3767: /**
3768: * @return List list of FieldInfo objects that are not primitive types or String's.
3769: */
3770: protected List getObjectFieldsMetaDataAbs() { // excluding String
3771: ArrayList list = new ArrayList();
3772: FieldMetaData[] fields = cmd.stateFields;
3773: for (int i = 0; i < fields.length; i++) {
3774: FieldMetaData field = fields[i];
3775: if (!nonObjectClassTypeList.contains(field.type)) {
3776: if (field.managedFieldNo != -1) {
3777: list.add(field);
3778: }
3779: }
3780: }
3781: return list;
3782: }
3783:
3784: protected List getAllRealObjectFields() {
3785: ArrayList list = new ArrayList();
3786: FieldMetaData[] fields = cmd.stateFields;
3787: for (int i = 0; i < fields.length; i++) {
3788: FieldMetaData field = fields[i];
3789: if (!realNonObjectClassTypeList.contains(field.type)) {
3790: list.add(field);
3791: }
3792: }
3793: return list;
3794: }
3795:
3796: protected List getRealObjectFields(int index) {
3797: int to = ((index + 1) * 32) - 1;
3798: int from = (index * 32) - 1;
3799: ArrayList list = new ArrayList();
3800: FieldMetaData[] fields = cmd.stateFields;
3801: for (int i = 0; i < fields.length; i++) {
3802: FieldMetaData field = fields[i];
3803: if (!realNonObjectClassTypeList.contains(field.type)) {
3804: if (field.stateFieldNo > from
3805: && field.stateFieldNo <= to) {
3806: list.add(field);
3807: }
3808: }
3809: }
3810: return list;
3811: }
3812:
3813: protected int getPrimaryHash(int index) {
3814: int hash = 0;
3815: List list = getPrimaryFields(index);
3816: for (Iterator iter = list.iterator(); iter.hasNext();) {
3817: FieldMetaData fmd = (FieldMetaData) iter.next();
3818: hash += getFieldIndex(fmd.stateFieldNo);
3819: }
3820: return hash;
3821: }
3822:
3823: protected int getSecondaryHash(int index) {
3824: int hash = 0;
3825: List list = getSecondaryFields(index);
3826: for (Iterator iter = list.iterator(); iter.hasNext();) {
3827: FieldMetaData fmd = (FieldMetaData) iter.next();
3828: hash += getFieldIndex(fmd.stateFieldNo);
3829: }
3830: return hash;
3831: }
3832:
3833: protected List getPrimaryFields(int index) {
3834: ArrayList primFields = new ArrayList();
3835: List list = getFields(index);
3836: for (Iterator iter = list.iterator(); iter.hasNext();) {
3837: FieldMetaData fmd = (FieldMetaData) iter.next();
3838: if (fmd.primaryField) {
3839: primFields.add(fmd);
3840: }
3841: }
3842: return primFields;
3843: }
3844:
3845: protected List getPrimaryFields() {
3846: ArrayList primFields = new ArrayList();
3847: FieldMetaData[] fields = cmd.stateFields;
3848: primFields.ensureCapacity(fields.length);
3849: for (int i = 0; i < fields.length; i++) {
3850: FieldMetaData fmd = fields[i];
3851: if (fmd.primaryField) {
3852: primFields.add(fmd);
3853: }
3854: }
3855: return primFields;
3856: }
3857:
3858: protected List getSecondaryFields() {
3859: ArrayList primFields = new ArrayList();
3860: FieldMetaData[] fields = cmd.stateFields;
3861: primFields.ensureCapacity(fields.length);
3862: for (int i = 0; i < fields.length; i++) {
3863: FieldMetaData fmd = fields[i];
3864: if (fmd.secondaryField) {
3865: primFields.add(fmd);
3866: }
3867: }
3868: return primFields;
3869: }
3870:
3871: protected List getSecondaryFields(int index) {
3872: ArrayList primFields = new ArrayList();
3873: List list = getFields(index);
3874: for (Iterator iter = list.iterator(); iter.hasNext();) {
3875: FieldMetaData fmd = (FieldMetaData) iter.next();
3876: if (fmd.secondaryField) {
3877: primFields.add(fmd);
3878: }
3879: }
3880: return primFields;
3881: }
3882:
3883: protected List getFields(int index) {
3884: int to = ((index + 1) * 32) - 1;
3885: int from = (index * 32) - 1;
3886: ArrayList list = new ArrayList();
3887: FieldMetaData[] fields = cmd.stateFields;
3888: for (int i = 0; i < fields.length; i++) {
3889: FieldMetaData field = fields[i];
3890: if (field.stateFieldNo > from && field.stateFieldNo <= to) {
3891: list.add(field);
3892: }
3893: }
3894: return list;
3895: }
3896:
3897: protected int getPrimativeHashForIndex(int index) {
3898: int hash = 0;
3899: int to = ((index + 1) * 32) - 1;
3900: int from = (index * 32) - 1;
3901: FieldMetaData[] fields = cmd.stateFields;
3902: for (int i = 0; i < fields.length; i++) {
3903: FieldMetaData field = fields[i];
3904: if (field.stateFieldNo > from && field.stateFieldNo <= to) {
3905: if (field.type.isPrimitive()) {
3906: hash += getFieldIndex(field.stateFieldNo);
3907: }
3908: }
3909: }
3910: return hash;
3911: }
3912:
3913: protected List getPass1Fields(int index) {
3914: int to = ((index + 1) * 32) - 1;
3915: int from = (index * 32) - 1;
3916: ArrayList list = new ArrayList();
3917: FieldMetaData[] fields = cmd.stateFields;
3918: for (int i = 0; i < fields.length; i++) {
3919: FieldMetaData field = fields[i];
3920: if (field.stateFieldNo > from && field.stateFieldNo <= to) {
3921: if (field.primaryField) {
3922: list.add(field);
3923: }
3924: }
3925: }
3926: return list;
3927: }
3928:
3929: protected List getPass2Fields(int index) {
3930: int to = ((index + 1) * 32) - 1;
3931: int from = (index * 32) - 1;
3932: ArrayList list = new ArrayList();
3933: FieldMetaData[] fields = cmd.stateFields;
3934: for (int i = 0; i < fields.length; i++) {
3935: FieldMetaData field = fields[i];
3936: if (field.stateFieldNo > from && field.stateFieldNo <= to) {
3937: if (field.secondaryField) {
3938: list.add(field);
3939: }
3940: }
3941: }
3942: return list;
3943: }
3944:
3945: protected List getOIDsFieldsMetaData() {
3946: ArrayList list = new ArrayList();
3947: FieldMetaData[] fields = cmd.stateFields;
3948: for (int i = 0; i < fields.length; i++) {
3949: FieldMetaData field = fields[i];
3950: if (field.category == MDStatics.CATEGORY_REF
3951: || field.category == MDStatics.CATEGORY_POLYREF) {
3952: list.add(field);
3953: }
3954: }
3955: return list;
3956: }
3957:
3958: protected List getPass1FieldAndRefOrPolyRefFields(int index) {
3959: int to = ((index + 1) * 32) - 1;
3960: int from = (index * 32) - 1;
3961: ArrayList list = new ArrayList();
3962: FieldMetaData[] fields = cmd.stateFields;
3963: for (int i = 0; i < fields.length; i++) {
3964: FieldMetaData field = fields[i];
3965: if (field.stateFieldNo > from && field.stateFieldNo <= to) {
3966: if (field.primaryField) {
3967: if (field.category == MDStatics.CATEGORY_REF
3968: || field.category == MDStatics.CATEGORY_POLYREF) {
3969: list.add(field);
3970: }
3971: }
3972: }
3973: }
3974: return list;
3975: }
3976:
3977: protected LinkedList getDirectRefFieldsMetaData() {
3978: // int[] fieldnos = cmd.directRefStateFieldNos;
3979: LinkedList list = new LinkedList();
3980: FieldMetaData[] fields = cmd.stateFields;
3981: for (int i = 0; i < fields.length; i++) {
3982: FieldMetaData field = fields[i];
3983: if (field.isDirectRef()) {
3984: list.add(field);
3985: }
3986: }
3987:
3988: return list;
3989: }
3990:
3991: protected List getPass1FieldsMetaData() {
3992: ArrayList list = new ArrayList();
3993: FieldMetaData[] fields = cmd.stateFields;
3994: list.ensureCapacity(fields.length);
3995: for (int i = 0; i < fields.length; i++) {
3996: FieldMetaData field = fields[i];
3997: if (field.primaryField) {
3998: list.add(field);
3999: }
4000: }
4001: return list;
4002: }
4003:
4004: /**
4005: * This method generates public xxx getXXXField(int field)
4006: *
4007: * @param methodName the method that we are generating
4008: */
4009: protected void addGetXXXField(String methodName) {
4010: StringBuffer buf = new StringBuffer();
4011: Class type = (Class) getFieldToClass.get(methodName);
4012: buf.append("\n\tpublic final " + type.getName() + " "
4013: + methodName + "(int field){\n");
4014: List fields = getFields(type);
4015: if (fields.isEmpty()) {
4016: buf.append("\t\tthrow new " + FIELD_NOT_FOUND_EXCEPTION
4017: + "(\"There were no " + type.toString()
4018: + " fields found for field number \"+field);\n");
4019: } else if (fields.size() == 1) {
4020: for (Iterator singelIter = fields.iterator(); singelIter
4021: .hasNext();) {
4022: FieldMetaData info = (FieldMetaData) singelIter.next();
4023: buf.append("\t\tif (field == " + getFieldNo(info)
4024: + ") {\n");
4025: buf.append("\t\t\treturn "
4026: + getFieldName(getFieldNo(info)) + ";\n");
4027: buf.append("\t\t} else {\n");
4028: buf
4029: .append("\t\t\tthrow new "
4030: + FIELD_NOT_FOUND_EXCEPTION
4031: + "(\"The specified "
4032: + type.toString()
4033: + " field was not found for field number \"+field);\n\t\t}\n");
4034: }
4035: } else {
4036: buf.append("\t\tswitch (field) {\n");
4037: for (Iterator fieldIter = fields.iterator(); fieldIter
4038: .hasNext();) {
4039: FieldMetaData info = (FieldMetaData) fieldIter.next();
4040: buf.append("\t\t\tcase " + getFieldNo(info) + ":\n");
4041: buf.append("\t\t\t\treturn "
4042: + getFieldName(getFieldNo(info)) + ";\n\n");
4043: }
4044: buf.append("\t\t\tdefault:\n");
4045: buf
4046: .append("\t\t\t\tthrow new "
4047: + FIELD_NOT_FOUND_EXCEPTION
4048: + "(\"The specified "
4049: + type.toString()
4050: + " field was not found for field number \"+field);\n\t\t}\n");
4051: }
4052: buf.append("\t}\n");
4053: spec.addMethod(buf.toString());
4054: }
4055:
4056: /**
4057: * This method generates public xxx getXXXField(int field)
4058: *
4059: * @param type the type of method we are generating i.e Type.INT
4060: */
4061: protected void addGetXXXFieldAbs(Class type) {
4062: StringBuffer buf = new StringBuffer();
4063: buf.append("\n\tpublic final " + type.getName() + " "
4064: + (String) classToGetFieldAbs.get(type)
4065: + "(int absField){\n");
4066: List fields = getFieldsAbs(type);
4067: if (fields.isEmpty()) {
4068: buf.append("\t\tthrow new " + FIELD_NOT_FOUND_EXCEPTION
4069: + "(\"There were no " + type.toString()
4070: + " fields found for field number \"+absField);\n");
4071: } else if (fields.size() == 1) {
4072: for (Iterator singelIter = fields.iterator(); singelIter
4073: .hasNext();) {
4074: FieldMetaData info = (FieldMetaData) singelIter.next();
4075: buf.append("\t\tif (absField == " + getAbsFieldNo(info)
4076: + ") {\n");
4077: buf.append("\t\t\treturn "
4078: + getFieldName(getFieldNo(info)) + ";\n");
4079: buf.append("\t\t} else {\n");
4080: buf
4081: .append("\t\t\tthrow new "
4082: + FIELD_NOT_FOUND_EXCEPTION
4083: + "(\"The specified "
4084: + type.toString()
4085: + " field was not found for field number \"+absField);\n\t\t}\n");
4086: }
4087: } else {
4088: buf.append("\t\tswitch (absField) {\n");
4089: for (Iterator fieldIter = fields.iterator(); fieldIter
4090: .hasNext();) {
4091: FieldMetaData info = (FieldMetaData) fieldIter.next();
4092: buf.append("\t\t\tcase " + getAbsFieldNo(info) + ":\n");
4093: buf.append("\t\t\t\treturn "
4094: + getFieldName(getFieldNo(info)) + ";\n\n");
4095: }
4096: buf.append("\t\t\tdefault:\n");
4097: buf
4098: .append("\t\t\t\tthrow new "
4099: + FIELD_NOT_FOUND_EXCEPTION
4100: + "(\"The specified "
4101: + type.toString()
4102: + " field was not found for absField number \"+absField);\n\t\t}\n");
4103: }
4104: buf.append("\t}\n");
4105: spec.addMethod(buf.toString());
4106: }
4107:
4108: /**
4109: * This method generates public void setXXXField(int field, xxx newValue)
4110: *
4111: * @param type the type of method we are generating i.e Type.INT
4112: */
4113: protected void addSetXXXField(Class type) {
4114: StringBuffer buf = new StringBuffer();
4115: buf.append("\n\tpublic final void "
4116: + (String) classToSetField.get(type) + "(int field,"
4117: + type.getName() + " newValue){\n");
4118: List fields = getFields(type);
4119: if (fields.isEmpty()) {
4120: buf.append("\t\tthrow new " + FIELD_NOT_FOUND_EXCEPTION
4121: + "(\"There were no " + type.toString()
4122: + " fields found to set.\");\n");
4123: } else if (fields.size() == 1) {
4124: for (Iterator singelIter = fields.iterator(); singelIter
4125: .hasNext();) {
4126: FieldMetaData info = (FieldMetaData) singelIter.next();
4127: int fieldNo = getFieldNo(info);
4128: buf.append("\t\tif(field == " + fieldNo + "){\n ");
4129: buf.append("\t\t\t" + getFieldName(fieldNo)
4130: + " = newValue;\n");
4131: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4132: + " |= " + getFieldIndex(fieldNo) + ";\n");
4133: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4134: + " |= " + getFieldIndex(fieldNo) + ";\n");
4135: buf.append("\t\t} else {\n");
4136: buf.append("\t\t\tthrow new "
4137: + FIELD_NOT_FOUND_EXCEPTION
4138: + "(\"The specified " + type.toString()
4139: + " field was not found.\");\n");
4140: buf.append("\t\t}\n");
4141: }
4142: } else {
4143: buf.append("\t\tswitch(field){\n");
4144: for (Iterator fieldIter = fields.iterator(); fieldIter
4145: .hasNext();) {
4146: FieldMetaData info = (FieldMetaData) fieldIter.next();
4147: int fieldNo = getFieldNo(info);
4148: buf.append("\t\tcase " + getFieldNo(info) + ":\n");
4149: buf.append("\t\t\t" + getFieldName(fieldNo)
4150: + " = newValue;\n");
4151: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4152: + " |= " + getFieldIndex(fieldNo) + ";\n");
4153: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4154: + " |= " + getFieldIndex(fieldNo) + ";\n");
4155: buf.append("\t\t\tbreak;\n\n");
4156: }
4157: // Do default
4158: buf.append("\t\tdefault:\n");
4159: buf
4160: .append("\t\t\tthrow new "
4161: + FIELD_NOT_FOUND_EXCEPTION
4162: + "(\"The specified "
4163: + type.toString()
4164: + " field was not found for field number \"+field);\n\t\t}\n");
4165: }
4166: buf.append("\t}\n");
4167: spec.addMethod(buf.toString());
4168: }
4169:
4170: /**
4171: * This method generates public void setXXXField(int field, xxx newValue)
4172: *
4173: * @param type the type of method we are generating i.e Type.INT
4174: */
4175: protected void addSetXXXFieldAbs(Class type) {
4176: StringBuffer buf = new StringBuffer();
4177: buf.append("\n\tpublic final void "
4178: + (String) classToSetFieldAbs.get(type)
4179: + "(int absField," + type.getName() + " newValue){\n");
4180: List fields = getFieldsAbs(type);
4181: if (fields.isEmpty()) {
4182: buf.append("\t\tthrow new " + FIELD_NOT_FOUND_EXCEPTION
4183: + "(\"There were no " + type.toString()
4184: + " absField found to set.\");\n");
4185: } else if (fields.size() == 1) {
4186: for (Iterator singelIter = fields.iterator(); singelIter
4187: .hasNext();) {
4188: FieldMetaData info = (FieldMetaData) singelIter.next();
4189: int fieldNo = getFieldNo(info);
4190: buf.append("\t\tif(absField == " + getAbsFieldNo(info)
4191: + "){\n ");
4192: buf.append("\t\t\t" + getFieldName(fieldNo)
4193: + " = newValue;\n");
4194: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4195: + " |= " + getFieldIndex(fieldNo) + ";\n");
4196: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4197: + " |= " + getFieldIndex(fieldNo) + ";\n");
4198: buf.append("\t\t} else {\n");
4199: buf.append("\t\t\tthrow new "
4200: + FIELD_NOT_FOUND_EXCEPTION
4201: + "(\"The specified " + type.toString()
4202: + " absField was not found.\");\n");
4203: buf.append("\t\t}\n");
4204: }
4205: } else {
4206: buf.append("\t\tswitch(absField){\n");
4207: for (Iterator fieldIter = fields.iterator(); fieldIter
4208: .hasNext();) {
4209: FieldMetaData info = (FieldMetaData) fieldIter.next();
4210: int fieldNo = getFieldNo(info);
4211: buf.append("\t\tcase " + getAbsFieldNo(info) + ":\n");
4212: buf.append("\t\t\t" + getFieldName(fieldNo)
4213: + " = newValue;\n");
4214: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4215: + " |= " + getFieldIndex(fieldNo) + ";\n");
4216: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4217: + " |= " + getFieldIndex(fieldNo) + ";\n");
4218: buf.append("\t\t\tbreak;\n\n");
4219: }
4220: // Do default
4221: buf.append("\t\tdefault:\n");
4222: buf
4223: .append("\t\t\tthrow new "
4224: + FIELD_NOT_FOUND_EXCEPTION
4225: + "(\"The specified "
4226: + type.toString()
4227: + " field was not found for absField number \"+absField);\n\t\t}\n");
4228: }
4229: buf.append("\t}\n");
4230: spec.addMethod(buf.toString());
4231: }
4232:
4233: /**
4234: * This method generates public void setObjectField(int field, Object newValue)
4235: */
4236: protected void addSetObjectFieldUnresolved() {
4237: StringBuffer buf = new StringBuffer();
4238:
4239: buf
4240: .append("\n\tpublic final void setObjectFieldUnresolved(int field,Object newValue){\n");
4241: List fields = getObjectFields();
4242: if (fields.isEmpty()) {
4243: buf
4244: .append("\t\tthrow new "
4245: + FIELD_NOT_FOUND_EXCEPTION
4246: + "(\"There were no Object fields found to set.\");\n");
4247: } else if (fields.size() == 1) {
4248: for (Iterator singelIter = fields.iterator(); singelIter
4249: .hasNext();) {
4250: FieldMetaData info = (FieldMetaData) singelIter.next();
4251: int fieldNo = getFieldNo(info);
4252: buf.append("\t\tif(field == " + fieldNo + "){\n ");
4253: if (isObject(info)) {
4254: buf.append("\t\t\t" + getFieldName(fieldNo)
4255: + " = newValue;\n");
4256: } else {
4257: buf.append("\t\t\t" + getFieldName(fieldNo)
4258: + " = (" + info.type.getName()
4259: + ")newValue;\n");
4260: }
4261: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4262: + " |= " + getFieldIndex(fieldNo) + ";\n");
4263: buf.append("\t\t\t" + getResolvedFieldName(fieldNo)
4264: + " &= " + getFieldIndexMask(fieldNo) + ";\n");
4265: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4266: + " |= " + getFieldIndex(fieldNo) + ";\n");
4267:
4268: buf.append("\t\t} else {\n");
4269: buf.append("\t\t\tthrow new "
4270: + FIELD_NOT_FOUND_EXCEPTION
4271: + "(\"The specified " + info.type.getName()
4272: + " field was not found.\");\n");
4273: buf.append("\t\t}\n");
4274: }
4275: } else {
4276: buf.append("\t\tswitch(field){\n");
4277: for (Iterator fieldIter = fields.iterator(); fieldIter
4278: .hasNext();) {
4279: FieldMetaData info = (FieldMetaData) fieldIter.next();
4280: int fieldNo = getFieldNo(info);
4281: buf.append("\t\tcase " + getFieldNo(info) + ":\n");
4282:
4283: if (isObject(info)) {
4284: buf.append("\t\t\t" + getFieldName(fieldNo)
4285: + " = newValue;\n");
4286: } else {
4287: buf.append("\t\t\t" + getFieldName(fieldNo)
4288: + " = (" + info.type.getName()
4289: + ")newValue;\n");
4290: }
4291: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4292: + " |= " + getFieldIndex(fieldNo) + ";\n");
4293: buf.append("\t\t\t" + getResolvedFieldName(fieldNo)
4294: + " &= " + getFieldIndexMask(fieldNo) + ";\n");
4295: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4296: + " |= " + getFieldIndex(fieldNo) + ";\n");
4297:
4298: buf.append("\t\t\tbreak;\n\n");
4299: }
4300: // Do default
4301: buf.append("\t\tdefault:\n");
4302: buf
4303: .append("\t\t\tthrow new "
4304: + FIELD_NOT_FOUND_EXCEPTION
4305: + "(\"The specified Object field was not found for field number \"+field);\n\t\t}\n");
4306:
4307: }
4308: buf.append("\t}\n");
4309: spec.addMethod(buf.toString());
4310: }
4311:
4312: /**
4313: * This method generates public void setObjectField(int field, Object newValue)
4314: */
4315: protected void addSetObjectField() {
4316: StringBuffer buf = new StringBuffer();
4317: buf
4318: .append("\n\tpublic final void setObjectField(int field, Object newValue){\n");
4319: List fields = getObjectFields();
4320: if (fields.isEmpty()) {
4321: buf
4322: .append("\t\tthrow new "
4323: + FIELD_NOT_FOUND_EXCEPTION
4324: + "(\"There were no Object fields found to set.\");\n");
4325: } else if (fields.size() == 1) {
4326: for (Iterator singelIter = fields.iterator(); singelIter
4327: .hasNext();) {
4328: FieldMetaData info = (FieldMetaData) singelIter.next();
4329: int fieldNo = getFieldNo(info);
4330: buf.append("\t\tif(field == " + fieldNo + "){\n ");
4331: if (isObject(info)) {
4332: buf.append("\t\t\t" + getFieldName(fieldNo)
4333: + " = newValue;\n");
4334: } else {
4335: buf.append("\t\t\t" + getFieldName(fieldNo)
4336: + " = (" + info.type.getName()
4337: + ")newValue;\n");
4338: }
4339: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4340: + " |= " + getFieldIndex(fieldNo) + ";\n");
4341: buf.append("\t\t\t" + getResolvedFieldName(fieldNo)
4342: + " |= " + getFieldIndex(fieldNo) + ";\n");
4343: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4344: + " |= " + getFieldIndex(fieldNo) + ";\n");
4345:
4346: buf.append("\t\t} else {\n");
4347: buf.append("\t\t\tthrow new "
4348: + FIELD_NOT_FOUND_EXCEPTION
4349: + "(\"The specified " + info.type.getName()
4350: + " field was not found.\");\n");
4351: buf.append("\t\t}\n");
4352: }
4353: } else {
4354: buf.append("\t\tswitch(field){\n");
4355: for (Iterator fieldIter = fields.iterator(); fieldIter
4356: .hasNext();) {
4357: FieldMetaData info = (FieldMetaData) fieldIter.next();
4358: int fieldNo = getFieldNo(info);
4359: buf.append("\t\tcase " + getFieldNo(info) + ":\n");
4360:
4361: if (isObject(info)) {
4362: buf.append("\t\t\t" + getFieldName(fieldNo)
4363: + " = newValue;\n");
4364: } else {
4365: buf.append("\t\t\t" + getFieldName(fieldNo)
4366: + " = (" + info.type.getName()
4367: + ")newValue;\n");
4368: }
4369: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4370: + " |= " + getFieldIndex(fieldNo) + ";\n");
4371: buf.append("\t\t\t" + getResolvedFieldName(fieldNo)
4372: + " |= " + getFieldIndex(fieldNo) + ";\n");
4373: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4374: + " |= " + getFieldIndex(fieldNo) + ";\n");
4375:
4376: buf.append("\t\t\tbreak;\n\n");
4377: }
4378: // Do default
4379: buf.append("\t\tdefault:\n");
4380: buf
4381: .append("\t\t\tthrow new "
4382: + FIELD_NOT_FOUND_EXCEPTION
4383: + "(\"The specified Object field was not found for field number \"+field);\n\t\t}\n");
4384:
4385: }
4386: buf.append("\t}\n");
4387: spec.addMethod(buf.toString());
4388: }
4389:
4390: /**
4391: * This method generates public void setObjectField(int field, Object newValue)
4392: */
4393: protected void addSetObjectFieldUnresolvedAbs() {
4394: StringBuffer buf = new StringBuffer();
4395:
4396: buf
4397: .append("\n\tpublic final void setObjectFieldUnresolvedAbs(int absfield,Object newValue){\n");
4398: List fields = getObjectFieldsAbs();
4399: if (fields.isEmpty()) {
4400: buf
4401: .append("\t\tthrow new "
4402: + FIELD_NOT_FOUND_EXCEPTION
4403: + "(\"There were no Object fields found to set.\");\n");
4404: } else if (fields.size() == 1) {
4405: for (Iterator singelIter = fields.iterator(); singelIter
4406: .hasNext();) {
4407: FieldMetaData info = (FieldMetaData) singelIter.next();
4408: int fieldNo = getFieldNo(info);
4409: buf.append("\t\tif(absfield == " + getAbsFieldNo(info)
4410: + "){\n ");
4411: if (isObject(info)) {
4412: buf.append("\t\t\t" + getFieldName(fieldNo)
4413: + " = newValue;\n");
4414: } else {
4415: buf.append("\t\t\t" + getFieldName(fieldNo)
4416: + " = (" + info.type.getName()
4417: + ")newValue;\n");
4418: }
4419: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4420: + " |= " + getFieldIndex(fieldNo) + ";\n");
4421: buf.append("\t\t\t" + getResolvedFieldName(fieldNo)
4422: + " &= " + getFieldIndexMask(fieldNo) + ";\n");
4423: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4424: + " |= " + getFieldIndex(fieldNo) + ";\n");
4425:
4426: buf.append("\t\t} else {\n");
4427: buf.append("\t\t\tthrow new "
4428: + FIELD_NOT_FOUND_EXCEPTION
4429: + "(\"The specified " + info.type.getName()
4430: + " field was not found.\");\n");
4431: buf.append("\t\t}\n");
4432: }
4433: } else {
4434: buf.append("\t\tswitch(absfield){\n");
4435: for (Iterator fieldIter = fields.iterator(); fieldIter
4436: .hasNext();) {
4437: FieldMetaData info = (FieldMetaData) fieldIter.next();
4438: int fieldNo = getFieldNo(info);
4439: buf.append("\t\tcase " + getAbsFieldNo(info) + ":\n");
4440: if (isObject(info)) {
4441: buf.append("\t\t\t" + getFieldName(fieldNo)
4442: + " = newValue;\n");
4443: } else {
4444: buf.append("\t\t\t" + getFieldName(fieldNo)
4445: + " = (" + info.type.getName()
4446: + ")newValue;\n");
4447: }
4448: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4449: + " |= " + getFieldIndex(fieldNo) + ";\n");
4450: buf.append("\t\t\t" + getResolvedFieldName(fieldNo)
4451: + " &= " + getFieldIndexMask(fieldNo) + ";\n");
4452: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4453: + " |= " + getFieldIndex(fieldNo) + ";\n");
4454:
4455: buf.append("\t\t\tbreak;\n\n");
4456: }
4457: // Do default
4458: buf.append("\t\tdefault:\n");
4459: buf
4460: .append("\t\t\tthrow new "
4461: + FIELD_NOT_FOUND_EXCEPTION
4462: + "(\"The specified Object field was not found for field number \"+absfield);\n\t\t}\n");
4463:
4464: }
4465: buf.append("\t}\n");
4466: spec.addMethod(buf.toString());
4467: }
4468:
4469: /**
4470: * This method generates public void setObjectField(int field, Object newValue)
4471: */
4472: protected void addSetObjectFieldAbs() {
4473: StringBuffer buf = new StringBuffer();
4474:
4475: buf
4476: .append("\n\tpublic final void setObjectFieldAbs(int absfield, Object newValue){\n");
4477: List fields = getObjectFieldsAbs();
4478: if (fields.isEmpty()) {
4479: buf
4480: .append("\t\tthrow new "
4481: + FIELD_NOT_FOUND_EXCEPTION
4482: + "(\"There were no Object fields found to set.\");\n");
4483: } else if (fields.size() == 1) {
4484: for (Iterator singelIter = fields.iterator(); singelIter
4485: .hasNext();) {
4486: FieldMetaData info = (FieldMetaData) singelIter.next();
4487: int fieldNo = getFieldNo(info);
4488: buf.append("\t\tif(absfield == " + getAbsFieldNo(info)
4489: + "){\n ");
4490: if (isObject(info)) {
4491: buf.append("\t\t\t" + getFieldName(fieldNo)
4492: + " = newValue;\n");
4493: } else {
4494: buf.append("\t\t\t" + getFieldName(fieldNo)
4495: + " = (" + info.type.getName()
4496: + ")newValue;\n");
4497: }
4498: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4499: + " |= " + getFieldIndex(fieldNo) + ";\n");
4500: buf.append("\t\t\t" + getResolvedFieldName(fieldNo)
4501: + " |= " + getFieldIndex(fieldNo) + ";\n");
4502: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4503: + " |= " + getFieldIndex(fieldNo) + ";\n");
4504:
4505: buf.append("\t\t} else {\n");
4506: buf.append("\t\t\tthrow new "
4507: + FIELD_NOT_FOUND_EXCEPTION
4508: + "(\"The specified " + info.type.getName()
4509: + " field was not found.\");\n");
4510: buf.append("\t\t}\n");
4511: }
4512: } else {
4513: buf.append("\t\tswitch(absfield){\n");
4514: for (Iterator fieldIter = fields.iterator(); fieldIter
4515: .hasNext();) {
4516: FieldMetaData info = (FieldMetaData) fieldIter.next();
4517: int fieldNo = getFieldNo(info);
4518: buf.append("\t\tcase " + getAbsFieldNo(info) + ":\n");
4519:
4520: if (isObject(info)) {
4521: buf.append("\t\t\t" + getFieldName(fieldNo)
4522: + " = newValue;\n");
4523: } else {
4524: buf.append("\t\t\t" + getFieldName(fieldNo)
4525: + " = (" + info.type.getName()
4526: + ")newValue;\n");
4527: }
4528: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4529: + " |= " + getFieldIndex(fieldNo) + ";\n");
4530: buf.append("\t\t\t" + getResolvedFieldName(fieldNo)
4531: + " |= " + getFieldIndex(fieldNo) + ";\n");
4532: buf.append("\t\t\t" + getDirtyFieldName(fieldNo)
4533: + " |= " + getFieldIndex(fieldNo) + ";\n");
4534:
4535: buf.append("\t\t\tbreak;\n\n");
4536: }
4537: // Do default
4538: buf.append("\t\tdefault:\n");
4539: buf
4540: .append("\t\t\tthrow new "
4541: + FIELD_NOT_FOUND_EXCEPTION
4542: + "(\"The specified Object field was not found for field number \"+absfield);\n\t\t}\n");
4543:
4544: }
4545: buf.append("\t}\n");
4546: spec.addMethod(buf.toString());
4547: }
4548:
4549: protected void addHasSameFields() {
4550: StringBuffer buf = new StringBuffer();
4551:
4552: /*
4553: public final boolean hasSameFields(State state) {
4554: HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff s = (HYPERDRIVE_STATE_com_versant_core_jdo_junit_test0_model_GuiStuff)state;
4555: return (filled0 ^ s.filled0) == 0 && (filled1 ^ s.filled1) == 0 && (filled2 ^ s.filled2) == 0;
4556: }
4557: */
4558:
4559: buf
4560: .append("\n\tpublic final boolean hasSameFields(State state){\n");
4561: buf.append("\t\t" + className + " s = (" + className
4562: + ")state;\n");
4563: int num = getNumOfControlFields();
4564: for (int i = 0; i < num; i++) {
4565: if (i == 0) {
4566: buf.append("\t\treturn (filled0 ^ s.filled0) == 0");
4567: } else {
4568: buf.append(" && (filled" + i + " ^ s.filled" + i
4569: + ") == 0");
4570: }
4571: }
4572: buf.append(";\n");
4573: buf.append("\t}\n");
4574: spec.addMethod(buf.toString());
4575: }
4576:
4577: /**
4578: * This method generates public void setInternalXXXField(int field, xxx newValue)
4579: *
4580: * @param type the type of method we are generating i.e Type.INT
4581: */
4582: protected void addSetInternalXXXField(Class type) {
4583: StringBuffer buf = new StringBuffer();
4584: buf.append("\n\tpublic final void "
4585: + (String) classToInternalSetField.get(type)
4586: + "(int field," + type.getName() + " newValue){\n");
4587: List fields = getFields(type);
4588: if (fields.isEmpty()) {
4589: buf.append("\t\tthrow new " + FIELD_NOT_FOUND_EXCEPTION
4590: + "(\"There were no " + type.toString()
4591: + " fields found to set.\");\n\t}\n");
4592: } else if (fields.size() == 1) {
4593: for (Iterator singelIter = fields.iterator(); singelIter
4594: .hasNext();) {
4595: FieldMetaData info = (FieldMetaData) singelIter.next();
4596: int fieldNo = getFieldNo(info);
4597: buf.append("\t\tif(field == " + fieldNo + "){\n ");
4598: buf.append("\t\t\t" + getFieldName(fieldNo)
4599: + " = newValue;\n");
4600: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4601: + " |= " + getFieldIndex(fieldNo) + ";\n");
4602: buf.append("\t\t} else {\n");
4603: buf
4604: .append("\t\t\tthrow new JDOFatalInternalException(\"The specified "
4605: + type.getName()
4606: + " field was not found.\");\n");
4607: buf.append("\t\t}\n");
4608: buf.append("\t}\n");
4609: }
4610: } else {
4611: buf.append("\t\tswitch(field){\n");
4612: for (Iterator fieldIter = fields.iterator(); fieldIter
4613: .hasNext();) {
4614: FieldMetaData info = (FieldMetaData) fieldIter.next();
4615: int fieldNo = getFieldNo(info);
4616: buf.append("\t\tcase " + getFieldNo(info) + ":\n");
4617: buf.append("\t\t\t" + getFieldName(fieldNo)
4618: + " = newValue;\n");
4619: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4620: + " |= " + getFieldIndex(fieldNo) + ";\n");
4621: buf.append("\t\t\tbreak;\n\n");
4622: }
4623: // Do default
4624: buf.append("\t\tdefault:\n");
4625: buf
4626: .append("\t\t\tthrow new JDOFatalInternalException(\"The specified "
4627: + type.getName()
4628: + " field was not found.\");\n");
4629: buf.append("\t\t}\n");
4630: buf.append("\t}\n");
4631: }
4632: spec.addMethod(buf.toString());
4633: }
4634:
4635: /**
4636: * This method generates public void setInternalXXXField(int field, xxx newValue)
4637: *
4638: * @param type the type of method we are generating i.e Type.INT
4639: */
4640: protected void addSetInternalXXXFieldAbs(Class type) {
4641: StringBuffer buf = new StringBuffer();
4642: buf.append("\n\tpublic final void "
4643: + (String) classToInternalSetFieldAbs.get(type)
4644: + "(int absField," + type.getName() + " newValue){\n");
4645: List fields = getFieldsAbs(type);
4646: if (fields.isEmpty()) {
4647: buf.append("\t\tthrow new " + FIELD_NOT_FOUND_EXCEPTION
4648: + "(\"There were no " + type.toString()
4649: + " fields found to set.\");\n");
4650: } else if (fields.size() == 1) {
4651: for (Iterator singelIter = fields.iterator(); singelIter
4652: .hasNext();) {
4653: FieldMetaData info = (FieldMetaData) singelIter.next();
4654: int fieldNo = getFieldNo(info);
4655: buf.append("\t\tif(absField == " + getAbsFieldNo(info)
4656: + "){\n ");
4657: buf.append("\t\t\t" + getFieldName(fieldNo)
4658: + " = newValue;\n");
4659: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4660: + " |= " + getFieldIndex(fieldNo) + ";\n");
4661: buf.append("\t\t} else {\n");
4662: buf.append("\t\t\tthrow new "
4663: + FIELD_NOT_FOUND_EXCEPTION
4664: + "(\"The specified " + type.toString()
4665: + " field was not found.\");\n");
4666: buf.append("\t\t}\n");
4667: }
4668: } else {
4669: buf.append("\t\tswitch(absField){\n");
4670: for (Iterator fieldIter = fields.iterator(); fieldIter
4671: .hasNext();) {
4672: FieldMetaData info = (FieldMetaData) fieldIter.next();
4673: int fieldNo = getFieldNo(info);
4674: buf.append("\t\tcase " + getAbsFieldNo(info) + ":\n");
4675: buf.append("\t\t\t" + getFieldName(fieldNo)
4676: + " = newValue;\n");
4677: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4678: + " |= " + getFieldIndex(fieldNo) + ";\n");
4679: buf.append("\t\t\tbreak;\n\n");
4680: }
4681: // Do default
4682: buf.append("\t\tdefault:\n");
4683: buf
4684: .append("\t\t\tthrow new "
4685: + FIELD_NOT_FOUND_EXCEPTION
4686: + "(\"The specified "
4687: + type.toString()
4688: + " field was not found for field number \"+absField);\n\t\t}\n");
4689:
4690: }
4691: buf.append("\t}\n");
4692: spec.addMethod(buf.toString());
4693: }
4694:
4695: protected int getFieldNo(FieldMetaData fmd) {
4696: return fmd.stateFieldNo;
4697: }
4698:
4699: protected int getAbsFieldNo(FieldMetaData fmd) {
4700: return fmd.managedFieldNo;
4701: }
4702:
4703: /**
4704: * This method generates public void setObjectField(int field, Object newValue)
4705: */
4706: protected void addSetInternalObjectField() {
4707: StringBuffer buf = new StringBuffer();
4708:
4709: buf
4710: .append("\n\tpublic final void setInternalObjectField(int field,Object newValue){\n");
4711: List fields = getObjectFields();
4712: if (fields.isEmpty()) {
4713: buf
4714: .append("\t\tthrow new "
4715: + FIELD_NOT_FOUND_EXCEPTION
4716: + "(\"There were no Object fields found to set.\");\n\t}\n");
4717: } else if (fields.size() == 1) {
4718: for (Iterator singelIter = fields.iterator(); singelIter
4719: .hasNext();) {
4720: FieldMetaData info = (FieldMetaData) singelIter.next();
4721: int fieldNo = getFieldNo(info);
4722: buf.append("\t\tif(field == " + fieldNo + "){\n ");
4723: if (isObject(info)) {
4724: buf.append("\t\t\t" + getFieldName(fieldNo)
4725: + " = newValue;\n");
4726: } else {
4727: buf.append("\t\t\t" + getFieldName(fieldNo)
4728: + " = (" + info.type.getName()
4729: + ")newValue;\n");
4730: }
4731: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4732: + " |= " + getFieldIndex(fieldNo) + ";\n");
4733: buf.append("\t\t} else {\n");
4734: buf.append("\t\t\tthrow new "
4735: + FIELD_NOT_FOUND_EXCEPTION
4736: + "(\"The specified " + info.type.getName()
4737: + " field was not found.\");\n");
4738: buf.append("\t\t}\n\t}\n");
4739: }
4740: } else {
4741: buf.append("\t\tswitch(field){\n");
4742: for (Iterator fieldIter = fields.iterator(); fieldIter
4743: .hasNext();) {
4744: FieldMetaData info = (FieldMetaData) fieldIter.next();
4745: int fieldNo = getFieldNo(info);
4746: buf.append("\t\tcase " + getFieldNo(info) + ":\n");
4747:
4748: if (isObject(info)) {
4749: buf.append("\t\t\t" + getFieldName(fieldNo)
4750: + " = newValue;\n");
4751: } else {
4752: buf.append("\t\t\t" + getFieldName(fieldNo)
4753: + " = (" + info.type.getName()
4754: + ")newValue;\n");
4755: }
4756: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4757: + " |= " + getFieldIndex(fieldNo) + ";\n");
4758: buf.append("\t\t\treturn;\n");
4759: }
4760: // Do default
4761: buf.append("\t\tdefault:\n");
4762: buf
4763: .append("\t\t\tthrow new JDOFatalInternalException(\"The specified Object field was not found.\");\n");
4764: buf.append("\t\t}\n");
4765: buf.append("\t}\n");
4766:
4767: }
4768: spec.addMethod(buf.toString());
4769: }
4770:
4771: /**
4772: * This method generates public void setObjectField(int field, Object newValue)
4773: */
4774: protected void addSetInternalObjectFieldAbs() {
4775: StringBuffer buf = new StringBuffer();
4776:
4777: buf
4778: .append("\n\tpublic final void setInternalObjectFieldAbs(int absField,Object newValue){\n");
4779: List fields = getObjectFieldsAbs();
4780: if (fields.isEmpty()) {
4781: buf
4782: .append("\t\tthrow new "
4783: + FIELD_NOT_FOUND_EXCEPTION
4784: + "(\"There were no Object fields found to set.\");\n");
4785: } else if (fields.size() == 1) {
4786: for (Iterator singelIter = fields.iterator(); singelIter
4787: .hasNext();) {
4788: FieldMetaData info = (FieldMetaData) singelIter.next();
4789: int fieldNo = getFieldNo(info);
4790: buf.append("\t\tif(absField == " + getAbsFieldNo(info)
4791: + "){\n ");
4792: if (isObject(info)) {
4793: buf.append("\t\t\t" + getFieldName(fieldNo)
4794: + " = newValue;\n");
4795: } else {
4796: buf.append("\t\t\t" + getFieldName(fieldNo)
4797: + " = (" + info.type.getName()
4798: + ")newValue;\n");
4799: }
4800: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4801: + " |= " + getFieldIndex(fieldNo) + ";\n");
4802: buf.append("\t\t} else {\n");
4803: buf.append("\t\t\tthrow new "
4804: + FIELD_NOT_FOUND_EXCEPTION
4805: + "(\"The specified " + info.type.getName()
4806: + " field was not found.\");\n");
4807: buf.append("\t\t}\n");
4808: }
4809: } else {
4810: buf.append("\t\tswitch(absField){\n");
4811: for (Iterator fieldIter = fields.iterator(); fieldIter
4812: .hasNext();) {
4813: FieldMetaData info = (FieldMetaData) fieldIter.next();
4814: int fieldNo = getFieldNo(info);
4815: buf.append("\t\tcase " + getAbsFieldNo(info) + ":\n");
4816:
4817: if (isObject(info)) {
4818: buf.append("\t\t\t" + getFieldName(fieldNo)
4819: + " = newValue;\n");
4820: } else {
4821: buf.append("\t\t\t" + getFieldName(fieldNo)
4822: + " = (" + info.type.getName()
4823: + ")newValue;\n");
4824: }
4825: buf.append("\t\t\t" + getFilledFieldName(fieldNo)
4826: + " |= " + getFieldIndex(fieldNo) + ";\n");
4827: buf.append("\t\t\tbreak;\n\n");
4828: }
4829: // Do default
4830: buf.append("\t\tdefault:\n");
4831: buf
4832: .append("\t\t\tthrow new "
4833: + FIELD_NOT_FOUND_EXCEPTION
4834: + "(\"The specified Object field was not found for field number \"+absField);\n\t\t}\n");
4835:
4836: }
4837: buf.append("\t}\n");
4838: spec.addMethod(buf.toString());
4839: }
4840:
4841: protected boolean isCollection(FieldMetaData info) {
4842: if (info.category == MDStatics.CATEGORY_COLLECTION) {
4843: return true;
4844: }
4845: return false;
4846: }
4847:
4848: protected boolean isArray(FieldMetaData info) {
4849: if (info.category == MDStatics.CATEGORY_ARRAY) {
4850: return true;
4851: }
4852: return false;
4853: }
4854:
4855: protected boolean isPrimitiveArray(FieldMetaData info) {
4856: if (info.category == MDStatics.CATEGORY_ARRAY) {
4857: if (info.componentType.isPrimitive()
4858: || imutableTypeList.contains(info.componentType)) {
4859: return true;
4860: }
4861: }
4862: return false;
4863: }
4864:
4865: protected boolean isPCArray(FieldMetaData fmd) {
4866: if (fmd.category == MDStatics.CATEGORY_ARRAY && fmd.scoField
4867: && fmd.isElementTypePC()) {
4868: return true;
4869: }
4870: return false;
4871: }
4872:
4873: protected boolean isMap(FieldMetaData info) {
4874: if (info.category == MDStatics.CATEGORY_MAP) {
4875: return true;
4876: }
4877: return false;
4878: }
4879:
4880: protected boolean isPolyRef(FieldMetaData info) {
4881: if (info.category == MDStatics.CATEGORY_POLYREF) {
4882: return true;
4883: }
4884: return false;
4885: }
4886:
4887: protected String getFieldName(int fieldNum) {
4888: return "_" + fieldNum;
4889: }
4890:
4891: protected int getNumOfControlFields() {
4892: return (totalNoOfFields / 32) + 1;
4893: }
4894:
4895: protected String getFilledFieldName(int fieldNum) {
4896: return FILLED_FIELD_NAME + (fieldNum / 32);
4897: }
4898:
4899: protected int getLocalVarIndex(int firstIndex, int fieldNo) {
4900: return (fieldNo / 32) + firstIndex;
4901: }
4902:
4903: protected String getDirtyFieldName(int fieldNum) {
4904: return DIRTY_FIELD_NAME + (fieldNum / 32);
4905: }
4906:
4907: protected String getResolvedFieldName(int fieldNum) {
4908: return RESOLVED_NAME + (fieldNum / 32);
4909: }
4910:
4911: protected int getFieldIndex(int fieldNum) {
4912: return 1 << fieldNum;
4913: }
4914:
4915: protected int getFieldIndexMask(int fieldNum) {
4916: return 0xffffffff ^ getFieldIndex(fieldNum);
4917: }
4918:
4919: protected ClassMetaData getTopPCSuperClassMetaData() {
4920: return cmd.pcHeirachy[0];
4921: }
4922:
4923: protected void addIsFieldNullorZero() {
4924: StringBuffer buf = new StringBuffer();
4925: buf
4926: .append("\n\tpublic boolean isFieldNullorZero(int stateFieldNo){\n");
4927: FieldMetaData[] fields = cmd.stateFields;
4928: int count = 0;
4929: for (int i = 0; i < fields.length; i++) {
4930: FieldMetaData f = fields[i];
4931: boolean obf = isObject(f);
4932: if (obf || Number.class.isAssignableFrom(f.type)
4933: || Boolean.class.isAssignableFrom(f.type)) {
4934: if (count++ == 0) {
4935: buf.append("\t\tswitch (stateFieldNo) {\n");
4936: }
4937: buf.append("\t\t\tcase " + i + ":\t");
4938: String fn = getFieldName(i);
4939: if (obf) {
4940: buf.append("return " + fn + " == null;\n");
4941: } else {
4942: switch (f.typeCode) {
4943: case MDStatics.BOOLEAN:
4944: buf.append("return !" + fn + ";\n");
4945: break;
4946: case MDStatics.BOOLEANW:
4947: buf.append("return " + fn
4948: + " == null || !((Boolean)" + fn
4949: + ").booleanValue();\n");
4950: break;
4951: case MDStatics.BYTEW:
4952: case MDStatics.SHORTW:
4953: case MDStatics.INTW:
4954: buf.append("return " + fn
4955: + " == null || ((Number)" + fn
4956: + ").intValue() == 0;\n");
4957: break;
4958: case MDStatics.LONGW:
4959: buf.append("return " + fn
4960: + " == null || ((Number)" + fn
4961: + ").longValue() == 0L;\n");
4962: break;
4963: case MDStatics.FLOATW:
4964: buf.append("return " + fn
4965: + " == null || ((Number)" + fn
4966: + ").floatValue() == 0.0f;\n");
4967: break;
4968: case MDStatics.DOUBLEW:
4969: case MDStatics.BIGDECIMAL:
4970: case MDStatics.BIGINTEGER:
4971: buf.append("return " + fn
4972: + " == null || ((Number)" + fn
4973: + ").doubleValue() == 0.0;\n");
4974: break;
4975: default:
4976: buf.append("return " + getFieldName(i)
4977: + " == 0;");
4978: }
4979: }
4980: }
4981: }
4982: if (count > 0) {
4983: buf.append("\t\t};\n");
4984: }
4985: buf.append("\t\nreturn false;\n");
4986: buf.append("\t}\n");
4987: spec.addMethod(buf.toString());
4988: }
4989:
4990: }
|