| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| <<<<<<< Updated upstream |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| ======= |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| >>>>>>> Stashed changes |
| * limitations under the License. |
| */ |
| |
| package org.apache.jdo.tck.util; |
| |
| import java.io.FileOutputStream; |
| import java.io.PrintWriter; |
| |
| public class ClassGenerator { |
| private final String[] fieldTypes = { |
| "boolean", |
| "byte", |
| "short", |
| "int", |
| "long", |
| "char", |
| "float", |
| "double", |
| "Boolean", |
| "Character", |
| "Byte", |
| "Short", |
| "Integer", |
| "Long", |
| "Float", |
| "Double", |
| "String", |
| "Locale", |
| "Date", |
| "BigDecimal", |
| "BigInteger", |
| "Object", |
| "SimpleClass", |
| "SimpleInterface" |
| }; |
| // includes a place holder for default package access |
| private final String[] accessSpecifiers = {"private ", "public ", "protected ", ""}; |
| |
| private final String[] fieldModifiers = { |
| "", |
| "static ", |
| "transient ", |
| "final ", |
| "volatile ", |
| "static transient ", |
| "static final ", |
| "static volatile ", |
| "transient final ", |
| "transient volatile ", |
| "static transient final ", |
| "static transient volatile " |
| }; |
| |
| private final String[] xmlPersistenceModifiers = { |
| "", |
| "persistence-modifier=\"none\"", |
| "persistence-modifier=\"persistent\"", |
| "persistence-modifier=\"transactional\"" |
| }; |
| |
| private final String[] xmlEmbeddedModifiers = {"", "embedded=\"true\"", "embedded=\"false\""}; |
| |
| private final String[] collectionTypes = { |
| "Collection", |
| "Map", |
| "Set", |
| "List", |
| "HashSet", |
| "ArrayList", |
| "HashMap", |
| "Hashtable", |
| "LinkedList", |
| "TreeMap", |
| "TreeSet", |
| "Vector", |
| "Array" |
| }; |
| |
| // Note: Any updates to elementtypes should include an update to elementsWithPackageInfo |
| private final String[] elementTypes = { |
| "Object", |
| "SimpleClass", |
| "SimpleInterface", |
| "String", |
| "Date", |
| "Locale", |
| "BigDecimal", |
| "BigInteger", |
| "Byte", |
| "Double", |
| "Float", |
| "Integer", |
| "Long", |
| "Short" |
| }; |
| |
| private final String[] elementsWithPackageInfo = { |
| "java.lang.Object", |
| "org.apache.jdo.tck.pc.fieldtypes.SimpleClass", |
| "org.apache.jdo.tck.pc.fieldtypes.SimpleInterface", |
| "java.lang.String", |
| "java.util.Date", |
| "java.util.Locale", |
| "java.math.BigDecimal", |
| "java.math.BigInteger", |
| "java.lang.Byte", |
| "java.lang.Double", |
| "java.lang.Float", |
| "java.lang.Integer", |
| "java.lang.Long", |
| "java.lang.Short" |
| }; |
| |
| private StringBuffer fieldSpecs = new StringBuffer(2000); |
| private StringBuffer isPersistent = new StringBuffer(200); |
| private StringBuffer isStatic = new StringBuffer(200); |
| private StringBuffer isFinalArray = new StringBuffer(2000); |
| |
| // can accomodate only 4000 fields, have to increase the capacity if the fields exceed 4000 |
| private static final boolean[] isFinal = new boolean[4000]; |
| |
| void generate() throws Exception { |
| final String twoSpaces = " "; |
| final String space = " "; |
| |
| for (String fieldType : fieldTypes) { |
| String classFile = (isPrimitive(fieldType) ? "FieldsOfPrimitive" : "FieldsOf") + fieldType; |
| |
| FileOutputStream xmlFout = new FileOutputStream(classFile + ".jdo.n"); |
| PrintWriter xmlPw = new PrintWriter(xmlFout); |
| FileOutputStream xmlFout1 = new FileOutputStream(classFile + ".jdo.a"); |
| PrintWriter xmlPw1 = new PrintWriter(xmlFout1); |
| FileOutputStream xmlFout2 = new FileOutputStream(classFile + ".jdo.d"); |
| PrintWriter xmlPw2 = new PrintWriter(xmlFout2); |
| startXmlMetaData(xmlPw); |
| startXmlMetaData(xmlPw1); |
| startXmlMetaData(xmlPw2); |
| |
| startXmlClass(xmlPw, classFile, 0); |
| startXmlClass(xmlPw1, classFile, 1); |
| startXmlClass(xmlPw2, classFile, 2); |
| |
| FileOutputStream fout = new FileOutputStream(classFile + ".java"); |
| PrintWriter pw = new PrintWriter(fout); |
| startClass(pw, classFile); |
| int fieldCounter = 0; |
| for (String accessSpecifier : accessSpecifiers) { |
| for (String fieldModifier : fieldModifiers) { |
| for (String xmlPersistenceModifier : xmlPersistenceModifiers) { |
| // do not generate persistence modifiers (persistent or transactional or none) |
| // for fields that cannot be persisted |
| |
| if ((fieldModifier.indexOf("static") >= 0 || fieldModifier.indexOf("final") >= 0) |
| && !xmlPersistenceModifier.equals("")) continue; |
| |
| /* original code |
| if(!isPersistenceCapable(fieldModifiers[k]) |
| && !xmlPersistenceModifiers[l].equals("")) |
| continue; |
| */ |
| for (String xmlEmbeddedModifier : xmlEmbeddedModifiers) { |
| // generate persistence modifiers (persistent or transactional or none) |
| // only for fields that can be persisted |
| // generate embedded modifiers only for persistent fields |
| |
| boolean fieldIsPersistent = |
| !(fieldModifier.indexOf("static") >= 0 |
| || fieldModifier.indexOf("final") >= 0 |
| || xmlPersistenceModifier.indexOf("none") >= 0 |
| || xmlPersistenceModifier.indexOf("transactional") >= 0 |
| || (fieldModifier.indexOf("transient") >= 0 |
| && xmlPersistenceModifier.indexOf("persistent") == -1)); |
| |
| if (!xmlEmbeddedModifier.equals("") && !fieldIsPersistent) continue; |
| |
| StringBuffer sb = new StringBuffer(); |
| sb.append(twoSpaces); |
| sb.append(accessSpecifier); |
| sb.append(fieldModifier); |
| sb.append(fieldType); |
| sb.append(space); |
| String fieldName = (fieldType + fieldCounter++); |
| // temporary fix to get around the bug in the enhancer code |
| if (!(xmlEmbeddedModifier.equals("") && xmlPersistenceModifier.equals(""))) { |
| printXmlField( |
| xmlPw, |
| "name=\"" |
| + fieldName |
| + "\" " |
| + xmlPersistenceModifier |
| + " " |
| + xmlEmbeddedModifier); |
| printXmlField( |
| xmlPw1, |
| "name=\"" |
| + fieldName |
| + "\" " |
| + xmlPersistenceModifier |
| + " " |
| + xmlEmbeddedModifier); |
| printXmlField( |
| xmlPw2, |
| "name=\"" |
| + fieldName |
| + "\" " |
| + xmlPersistenceModifier |
| + " " |
| + xmlEmbeddedModifier); |
| } // end temporary fix |
| sb.append(fieldName); |
| buildisPersistentArray(fieldIsPersistent); // add to isPersistentArray |
| buildisStaticArray(isStatic(fieldModifier)); // add to isStaticArray |
| buildFieldSpecs( |
| xmlPersistenceModifier.replace('"', ' ') |
| + " " |
| + xmlEmbeddedModifier.replace('"', ' ') |
| + sb); // add to the field specs array |
| isFinal[fieldCounter - 1] = fieldModifier.indexOf("final") >= 0; |
| if (isFinal[fieldCounter - 1]) sb.append(getInitializerForFinalTypes(fieldType)); |
| buildisFinalArray(isFinal[fieldCounter - 1]); |
| sb.append(";"); |
| pw.println(sb); |
| } |
| } |
| } |
| } |
| writeisPersistentArray(pw); |
| writeisStaticArray(pw); |
| writeisFinalArray(pw); |
| writeFieldSpecs(pw); |
| writeMethodGetLength(pw); |
| writeMethodGet(pw, fieldType, fieldCounter); |
| writeMethodSet(pw, fieldType, fieldCounter); |
| endClass(pw); |
| pw.close(); |
| fout.close(); |
| |
| endXmlClass(xmlPw); |
| endXmlClass(xmlPw1); |
| endXmlClass(xmlPw2); |
| endXmlMetaDeta(xmlPw); |
| endXmlMetaDeta(xmlPw1); |
| endXmlMetaDeta(xmlPw2); |
| xmlPw.close(); |
| xmlFout.close(); |
| xmlPw1.close(); |
| xmlFout1.close(); |
| xmlPw2.close(); |
| xmlFout2.close(); |
| } |
| } |
| |
| private void startClass(PrintWriter pw, String className) { |
| pw.println("package org.apache.jdo.tck.pc.fieldtypes;"); |
| pw.println(""); |
| pw.println(getImportStatements(className)); |
| pw.println("public class " + className + " { "); |
| pw.println(" public int identifier;"); |
| } |
| |
| private void endClass(PrintWriter pw) { |
| pw.println(""); |
| pw.println("}"); |
| } |
| |
| private void startXmlMetaData(PrintWriter pw) { |
| pw.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"); |
| pw.println("<!DOCTYPE jdo SYSTEM \"jdo.dtd\">"); |
| pw.println("<jdo>"); |
| pw.println("<package name=\"org.apache.jdo.tck.pc.fieldtypes\">"); |
| } |
| |
| private void endXmlMetaDeta(PrintWriter pw) { |
| pw.println("</package>"); |
| pw.println("</jdo>"); |
| } |
| |
| private void startXmlClass(PrintWriter pw, String className, int type) { |
| switch (type) { |
| case (0): |
| pw.println("<class name=\"" + className + "\">"); |
| break; |
| case (1): |
| pw.println("<class name=\"" + className + "\" identity-type=\"application\">"); |
| break; |
| case (2): |
| pw.println("<class name=\"" + className + "\" identity-type=\"datastore\">"); |
| break; |
| default: |
| System.out.println("Unsupported Type"); |
| } |
| } |
| |
| private void endXmlClass(PrintWriter pw) { |
| pw.println("</class>"); |
| } |
| |
| // need to check if we should support extents |
| // fieldName includes modifiers |
| private void printXmlField(PrintWriter pw, String fieldName) { |
| pw.println("<field " + fieldName + ">"); |
| pw.println("</field>"); |
| } |
| |
| // fieldname does not include any modifiers. |
| // element type includes package informaiton. |
| private void printXmlCollectionFieldWithEmbeddedElement( |
| PrintWriter pw, String fieldName, String elementType, String embeddedValue) { |
| pw.println("<field name=\"" + fieldName + "\" " + ">"); |
| pw.print("<collection element-type=" + "\"" + elementType + "\""); |
| if (!embeddedValue.equals("")) pw.print(" embedded-element=" + "\"" + embeddedValue + "\""); |
| pw.println(">"); |
| pw.println("</collection>"); |
| pw.println("</field>"); |
| } |
| |
| private void printXmlArrayFieldWithEmbeddedElement( |
| PrintWriter pw, String fieldName, String embeddedValue) { |
| pw.println("<field name=\"" + fieldName + "\" " + ">"); |
| pw.println("<array embedded-element=" + "\"" + embeddedValue + "\"" + ">"); |
| pw.println("</array>"); |
| pw.println("</field>"); |
| } |
| |
| private void printXmlMapField( |
| PrintWriter pw, |
| String fieldName, |
| String keyType, |
| String embeddedKey, |
| String valueType, |
| String embeddedValue) { |
| pw.println("<field name=\"" + fieldName + "\" " + ">"); |
| pw.print("<map "); |
| if (!keyType.equals("")) pw.print(" key-type=" + "\"" + keyType + "\""); |
| if (!embeddedKey.equals("")) pw.print(" embedded-key=" + "\"" + embeddedKey + "\""); |
| if (!valueType.equals("")) pw.print(" value-type=" + "\"" + valueType + "\""); |
| if (!embeddedValue.equals("")) pw.print(" embedded-value=" + "\"" + embeddedValue + "\""); |
| pw.println(">"); |
| pw.println("</map>"); |
| pw.println("</field>"); |
| } |
| |
| private String getInitializerForFinalTypes(String fieldType) throws Exception { |
| if (fieldType.equals("char")) return " = 'a'"; // primitive character, return 'a'; |
| else if (fieldType.equals("boolean")) return " = false"; // primitive boolean, return 'a'; |
| else if (Character.isLowerCase(fieldType.charAt(0))) |
| return " = 5"; // return 0 for all other primitive types |
| else if (fieldType.equals("Byte")) return " = Byte.valueOf((byte)5)"; |
| else if (fieldType.equals("Boolean")) return " = Boolean.FALSE"; |
| else if (fieldType.equals("Character")) return " = Character.valueOf('a')"; |
| else if (fieldType.equals("Short")) return " = Short.valueOf((short)5)"; |
| else if (fieldType.equals("Integer")) return " = Integer.valueOf((int)5)"; |
| else if (fieldType.equals("Long")) return " = Long.valueOf((long)5)"; |
| else if (fieldType.equals("Float")) return " = Float.valueOf((float)5)"; |
| else if (fieldType.equals("Double")) return " = Double.valueOf((double)5)"; |
| else if (fieldType.equals("String")) return " = new String(\"JDO TCK\")"; |
| else if (fieldType.equals("Locale")) return " = Locale.US"; |
| else if (fieldType.equals("BigDecimal")) return " = new BigDecimal(100.15)"; |
| else if (fieldType.equals("BigInteger")) return " = new BigInteger(\"100\")"; |
| else if (fieldType.equals("Collection")) return " = new HashSet()"; |
| else if (fieldType.equals("Set")) return " = new HashSet()"; |
| else if (fieldType.equals("HashSet")) return " = new HashSet()"; |
| else if (fieldType.equals("Object")) return " = new Object()"; |
| else if (fieldType.equals("SimpleClass")) return " = new SimpleClass()"; |
| else if (fieldType.equals("SimpleInterface")) return " = new SimpleClass()"; |
| else if (fieldType.equals("Date")) return " = new Date()"; |
| else throw new Exception("Unsupported FieldType " + fieldType); |
| } |
| |
| private String getImportStatements(String fieldType) { |
| if (fieldType.equals("FieldsOfLocale")) return "import java.util.*;"; |
| if (fieldType.equals("FieldsOfDate")) return "import java.util.*;"; |
| else if (fieldType.equals("FieldsOfBigDecimal")) return "import java.math.*;"; |
| else if (fieldType.equals("FieldsOfBigInteger")) return "import java.math.*;"; |
| else if (fieldType.equals("FieldsOfCollection")) return "import java.util.*;"; |
| else if (fieldType.equals("FieldsOfSet")) return "import java.util.*;"; |
| else if (fieldType.equals("FieldsOfHashSet")) return "import java.util.*;"; |
| else if (fieldType.indexOf("Collections") >= 0) |
| return "import java.util.*;\r\nimport java.math.*;"; |
| else return ""; |
| } |
| |
| private boolean isPrimitive(String fieldType) { |
| if (Character.isUpperCase(fieldType.charAt(0))) return false; |
| else return true; |
| } |
| |
| private boolean isPersistenceCapable(String fieldModifier) { |
| if (fieldModifier.indexOf("static") >= 0 |
| || fieldModifier.indexOf("final") >= 0 |
| || fieldModifier.indexOf("transient") >= 0) return false; |
| else return true; |
| } |
| |
| private boolean isStatic(String fieldModifier) { |
| if (fieldModifier.indexOf("static") >= 0) return true; |
| else return false; |
| } |
| |
| private boolean isFinal(String fieldModifier) { |
| return fieldModifier.indexOf("final") >= 0; |
| } |
| |
| private void buildisPersistentArray(boolean value) { |
| if (isPersistent.length() != 0) isPersistent.append(","); |
| if (value) isPersistent.append("true"); |
| else isPersistent.append("false"); |
| } |
| |
| private void buildisStaticArray(boolean value) { |
| if (isStatic.length() != 0) isStatic.append(","); |
| if (value) isStatic.append("true"); |
| else isStatic.append("false"); |
| } |
| |
| private void buildisFinalArray(boolean value) { |
| if (isFinalArray.length() != 0) isFinalArray.append(","); |
| if (value) isFinalArray.append("true"); |
| else isFinalArray.append("false"); |
| } |
| |
| private void writeisPersistentArray(PrintWriter pw) { |
| // have to go through this hoopla because pw.println(fieldSpecs.toString()); outputs only |
| // 1024 characters |
| char[] charArray = new char[isPersistent.length()]; |
| isPersistent.getChars(0, isPersistent.length(), charArray, 0); |
| pw.println(""); |
| pw.println("public static final boolean [] isPersistent = { "); |
| |
| int fieldCounter = 0; |
| for (char c : charArray) { |
| pw.print(c); |
| if (c == ',') { |
| fieldCounter++; |
| if (fieldCounter == 10) { |
| pw.println(""); |
| pw.flush(); |
| fieldCounter = 0; |
| } |
| } |
| } |
| pw.println(""); |
| pw.println(" };"); |
| isPersistent = new StringBuffer(2000); |
| } |
| |
| private void writeisStaticArray(PrintWriter pw) { |
| // have to go through this hoopla because pw.println(fieldSpecs.toString()); outputs only |
| // 1024 characters |
| char[] charArray = new char[isStatic.length()]; |
| isStatic.getChars(0, isStatic.length(), charArray, 0); |
| pw.println(""); |
| pw.println("public static final boolean [] isStatic = { "); |
| |
| int fieldCounter = 0; |
| for (char c : charArray) { |
| pw.print(c); |
| if (c == ',') { |
| fieldCounter++; |
| if (fieldCounter == 10) { |
| pw.println(""); |
| pw.flush(); |
| fieldCounter = 0; |
| } |
| } |
| } |
| pw.println(""); |
| pw.println(" };"); |
| isStatic = new StringBuffer(2000); |
| } |
| |
| private void writeisFinalArray(PrintWriter pw) { |
| // have to go through this hoopla because pw.println(fieldSpecs.toString()); outputs only |
| // 1024 characters |
| char[] charArray = new char[isFinalArray.length()]; |
| isFinalArray.getChars(0, isFinalArray.length(), charArray, 0); |
| pw.println(""); |
| pw.println("public static final boolean [] isFinal = { "); |
| |
| int fieldCounter = 0; |
| for (char c : charArray) { |
| pw.print(c); |
| if (c == ',') { |
| fieldCounter++; |
| if (fieldCounter == 10) { |
| pw.println(""); |
| pw.flush(); |
| fieldCounter = 0; |
| } |
| } |
| } |
| pw.println(""); |
| pw.println(" };"); |
| isFinalArray = new StringBuffer(2000); |
| } |
| |
| private void buildFieldSpecs(String field) { |
| if (fieldSpecs.length() != 0) fieldSpecs.append(","); |
| |
| fieldSpecs.append("\""); |
| fieldSpecs.append(field.trim()); |
| fieldSpecs.append("\""); |
| } |
| |
| private void writeFieldSpecs(PrintWriter pw) { |
| // have to go through this hoopla because pw.println(fieldSpecs.toString()); outputs only |
| // 1024 characters |
| char[] charArray = new char[fieldSpecs.length()]; |
| fieldSpecs.getChars(0, fieldSpecs.length(), charArray, 0); |
| pw.println(""); |
| pw.println(" public static final String [] fieldSpecs = { "); |
| |
| pw.print(" "); |
| for (char c : charArray) { |
| pw.print(c); |
| if (c == ',') { |
| pw.println(""); |
| pw.print(" "); |
| pw.flush(); |
| } |
| } |
| pw.println(""); |
| pw.println(" };"); |
| fieldSpecs = new StringBuffer(2000); |
| } |
| |
| private void writeMethodGetLength(PrintWriter pw) { |
| pw.println(" public int getLength()"); |
| pw.println(" {"); |
| pw.println(" return fieldSpecs.length;"); |
| pw.println(" }"); |
| } |
| |
| private void writeMethodGet(PrintWriter pw, String fieldType, int numberOfFields) { |
| pw.println(" public " + fieldType + " get(int index)"); |
| pw.println(" {"); |
| |
| pw.println(" switch (index)"); |
| pw.println(" {"); |
| for (int i = 0; i < numberOfFields; i++) { |
| pw.println(" case(" + i + "):"); |
| pw.println(" return " + fieldType + i + ";"); |
| } |
| pw.println(" default:"); |
| pw.println(" throw new IndexOutOfBoundsException();"); |
| pw.println(" }"); |
| pw.println(" }"); |
| } |
| |
| private void writeMethodGet( |
| PrintWriter pw, String fieldType, String[] fieldNames, int numFields) { |
| pw.println(" public " + fieldType + " get(int index)"); |
| pw.println(" {"); |
| |
| pw.println(" switch (index)"); |
| pw.println(" {"); |
| for (int i = 0; i < numFields; i++) { |
| pw.println(" case(" + i + "):"); |
| pw.println(" return " + fieldNames[i] + ";"); |
| } |
| pw.println(" default:"); |
| pw.println(" throw new IndexOutOfBoundsException();"); |
| pw.println(" }"); |
| pw.println(" }"); |
| } |
| |
| private void writeMethodSet(PrintWriter pw, String fieldType, int numberOfFields) { |
| pw.println(" public boolean set(int index," + fieldType + " value" + ")"); |
| pw.println(" {"); |
| pw.println(" if(fieldSpecs[index].indexOf(\"final\") != -1)"); |
| pw.println(" return false;"); |
| |
| pw.println(" switch (index)"); |
| pw.println(" {"); |
| for (int i = 0; i < numberOfFields; i++) { |
| if (!isFinal[i]) { |
| pw.println(" case(" + i + "):"); |
| pw.println(" " + fieldType + i + "= value" + ";"); |
| pw.println(" break;"); |
| } |
| } |
| pw.println(" default:"); |
| pw.println(" throw new IndexOutOfBoundsException();"); |
| pw.println(" }"); |
| pw.println(" return true;"); |
| pw.println(" }"); |
| } |
| |
| private void writeMethodSet( |
| PrintWriter pw, String fieldType, String[] fieldNames, int numFields) { |
| pw.println(" public boolean set(int index," + fieldType + " value" + ")"); |
| pw.println(" {"); |
| pw.println(" if(fieldSpecs[index].indexOf(\"final\") != -1)"); |
| pw.println(" return false;"); |
| |
| pw.println(" switch (index)"); |
| pw.println(" {"); |
| for (int i = 0; i < numFields; i++) { |
| // if(!isFinal[i]) { |
| pw.println(" case(" + i + "):"); |
| pw.println(" " + fieldNames[i] + "= value" + ";"); |
| pw.println(" break;"); |
| // } |
| } |
| pw.println(" default:"); |
| pw.println(" throw new IndexOutOfBoundsException();"); |
| pw.println(" }"); |
| pw.println(" return true;"); |
| pw.println(" }"); |
| } |
| |
| private void writeMethodSetForArray( |
| PrintWriter pw, String fieldType, String[] fieldNames, int numFields) { |
| pw.println(" public boolean set(int index," + fieldType + " value" + ")"); |
| pw.println(" {"); |
| pw.println(" if(fieldSpecs[index].indexOf(\"final\") != -1)"); |
| pw.println(" return false;"); |
| |
| pw.println(" switch (index)"); |
| pw.println(" {"); |
| for (int i = 0; i < numFields; i++) { |
| // if(!isFinal[i]) { |
| String fieldName = fieldNames[i]; |
| String valueType; |
| pw.println(" case(" + i + "):"); |
| int indexOfValueType = fieldName.indexOf("Of") + 2; |
| String valueTypeWithNumber = fieldName.substring(indexOfValueType); |
| int lastIndexOfValueType = 0; |
| for (int j = valueTypeWithNumber.length() - 1; j >= 0; j--) { |
| if (Character.isDigit(valueTypeWithNumber.charAt(j))) { |
| continue; |
| } else { |
| lastIndexOfValueType = j; |
| break; |
| } |
| } |
| valueType = valueTypeWithNumber.substring(0, lastIndexOfValueType + 1); |
| pw.println(" " + fieldNames[i] + "= (" + valueType + " []) value ;"); |
| pw.println(" break;"); |
| // } |
| } |
| pw.println(" default:"); |
| pw.println(" throw new IndexOutOfBoundsException();"); |
| pw.println(" }"); |
| pw.println(" return true;"); |
| pw.println(" }"); |
| } |
| |
| // generates Collection files for the different collectionTypes |
| // also, updates the corresponding xml files |
| // called by generate, after it is done dealing with the generic field types |
| void generateCollections() throws Exception { |
| final String[] embeddedElements = {"", "true", "false"}; |
| final String[] embeddedElementsForFieldSpec = { |
| "", "embedded-element=true", "embedded-element=false" |
| }; |
| for (String collectionType : collectionTypes) { |
| // Map has a lot of combinations, generate it separately |
| if (collectionType.indexOf("Map") >= 0 || collectionType.equals("Hashtable")) { |
| generateMapCollection(collectionType); |
| } else // Array and the other collections |
| { |
| String classFile = collectionType + "Collections"; |
| FileOutputStream fout = new FileOutputStream(classFile + ".java"); |
| PrintWriter pw = new PrintWriter(fout); |
| FileOutputStream xmlFout = new FileOutputStream(classFile + ".jdo.n"); |
| PrintWriter xmlPw = new PrintWriter(xmlFout); |
| FileOutputStream xmlFout1 = new FileOutputStream(classFile + ".jdo.a"); |
| PrintWriter xmlPw1 = new PrintWriter(xmlFout1); |
| FileOutputStream xmlFout2 = new FileOutputStream(classFile + ".jdo.d"); |
| PrintWriter xmlPw2 = new PrintWriter(xmlFout2); |
| |
| startClass(pw, classFile); |
| startXmlMetaData(xmlPw); |
| startXmlMetaData(xmlPw1); |
| startXmlMetaData(xmlPw2); |
| |
| startXmlClass(xmlPw, classFile, 0); |
| startXmlClass(xmlPw1, classFile, 1); |
| startXmlClass(xmlPw2, classFile, 2); |
| |
| int fieldCounter = 0; |
| String[] fieldNames = new String[elementTypes.length * embeddedElements.length]; |
| for (int j = 0; j < elementTypes.length; j++) { |
| if (elementTypes[j].equals("Locale") && collectionType.equals("TreeSet")) continue; |
| for (int k = 0; k < embeddedElements.length; k++) { |
| if (collectionType.equals("Array")) { |
| if (!embeddedElements[k].equals("")) { |
| fieldNames[fieldCounter] = collectionType + "Of" + elementTypes[j] + fieldCounter; |
| // pw.println(" public " + "Object [] "+ fieldNames[fieldCounter] |
| // +";"); |
| pw.println(" public " + elementTypes[j] + " [] " + fieldNames[fieldCounter] + ";"); |
| printXmlArrayFieldWithEmbeddedElement( |
| xmlPw, fieldNames[fieldCounter], embeddedElements[k]); |
| printXmlArrayFieldWithEmbeddedElement( |
| xmlPw1, fieldNames[fieldCounter], embeddedElements[k]); |
| printXmlArrayFieldWithEmbeddedElement( |
| xmlPw2, fieldNames[fieldCounter], embeddedElements[k]); |
| buildFieldSpecs( |
| embeddedElementsForFieldSpec[k] |
| + " " |
| + "public " |
| + elementTypes[j] |
| + " [] " |
| + fieldNames[fieldCounter]); // add to the |
| // field specs array*/ |
| |
| fieldCounter++; |
| } |
| } else // Collection |
| { |
| fieldNames[fieldCounter] = collectionType + "Of" + elementTypes[j] + fieldCounter; |
| pw.println(" public " + collectionType + " " + fieldNames[fieldCounter] + ";"); |
| printXmlCollectionFieldWithEmbeddedElement( |
| xmlPw, fieldNames[fieldCounter], elementsWithPackageInfo[j], embeddedElements[k]); |
| printXmlCollectionFieldWithEmbeddedElement( |
| xmlPw1, |
| fieldNames[fieldCounter], |
| elementsWithPackageInfo[j], |
| embeddedElements[k]); |
| printXmlCollectionFieldWithEmbeddedElement( |
| xmlPw2, |
| fieldNames[fieldCounter], |
| elementsWithPackageInfo[j], |
| embeddedElements[k]); |
| buildFieldSpecs( |
| embeddedElementsForFieldSpec[k] |
| + " " |
| + "public " |
| + collectionType |
| + " " |
| + fieldNames[fieldCounter]); // add to the field specs array*/ |
| fieldCounter++; |
| } |
| } |
| } |
| writeFieldSpecs(pw); |
| writeMethodGetLength(pw); |
| writeMethodGet( |
| pw, |
| collectionType.equals("Array") ? "Object [] " : collectionType, |
| fieldNames, |
| fieldCounter); |
| if (collectionType.equals("Array")) |
| writeMethodSetForArray(pw, "Object [] ", fieldNames, fieldCounter); |
| else writeMethodSet(pw, collectionType, fieldNames, fieldCounter); |
| |
| endClass(pw); |
| pw.close(); |
| fout.close(); |
| endXmlClass(xmlPw); |
| endXmlClass(xmlPw1); |
| endXmlClass(xmlPw2); |
| endXmlMetaDeta(xmlPw); |
| endXmlMetaDeta(xmlPw1); |
| endXmlMetaDeta(xmlPw2); |
| xmlPw.close(); |
| xmlFout.close(); |
| xmlPw1.close(); |
| xmlFout1.close(); |
| xmlPw2.close(); |
| xmlFout2.close(); |
| } |
| } |
| } |
| |
| private void generateMapCollection(String mapName) throws Exception { |
| final String[] keyTypes1 = {"String"}; |
| final String[] valueTypes1 = { |
| "Object", |
| "SimpleClass", |
| "SimpleInterface", |
| "String", |
| "Date", |
| "Locale", |
| "BigDecimal", |
| "BigInteger", |
| "Byte", |
| "Double", |
| "Float", |
| "Integer", |
| "Long", |
| "Short" |
| }; |
| final String[] keyTypes2 = { |
| "Object", |
| "SimpleClass", |
| "SimpleInterface", |
| "String", |
| "Date", |
| "BigDecimal", |
| "BigInteger", |
| "Byte", |
| "Double", |
| "Float", |
| "Integer", |
| "Long", |
| "Short" |
| }; |
| final String[] valueTypes2 = {"String"}; |
| |
| final String[][] keyTypes = {keyTypes1, keyTypes2}; |
| final String[][] valueTypes = {valueTypes1, valueTypes2}; |
| |
| String[] classNameArray = { |
| mapName + "StringKey" + "Collections", mapName + "StringValue" + "Collections" |
| }; |
| |
| for (int i = 0; i < classNameArray.length; i++) { |
| String classFile = classNameArray[i]; |
| FileOutputStream fout = new FileOutputStream(classFile + ".java"); |
| PrintWriter pw = new PrintWriter(fout); |
| FileOutputStream xmlFout = new FileOutputStream(classFile + ".jdo.n"); |
| PrintWriter xmlPw = new PrintWriter(xmlFout); |
| FileOutputStream xmlFout1 = new FileOutputStream(classFile + ".jdo.a"); |
| PrintWriter xmlPw1 = new PrintWriter(xmlFout1); |
| FileOutputStream xmlFout2 = new FileOutputStream(classFile + ".jdo.d"); |
| PrintWriter xmlPw2 = new PrintWriter(xmlFout2); |
| |
| startClass(pw, classFile); |
| startXmlMetaData(xmlPw); |
| startXmlMetaData(xmlPw1); |
| startXmlMetaData(xmlPw2); |
| |
| startXmlClass(xmlPw, classFile, 0); |
| startXmlClass(xmlPw1, classFile, 1); |
| startXmlClass(xmlPw2, classFile, 2); |
| |
| fillMapCollection(keyTypes[i], valueTypes[i], mapName, pw, xmlPw, xmlPw1, xmlPw2); |
| |
| endClass(pw); |
| pw.close(); |
| fout.close(); |
| endXmlClass(xmlPw); |
| endXmlClass(xmlPw1); |
| endXmlClass(xmlPw2); |
| endXmlMetaDeta(xmlPw); |
| endXmlMetaDeta(xmlPw1); |
| endXmlMetaDeta(xmlPw2); |
| xmlPw.close(); |
| xmlFout.close(); |
| xmlPw1.close(); |
| xmlFout1.close(); |
| xmlPw2.close(); |
| xmlFout2.close(); |
| } |
| } |
| |
| private void fillMapCollection( |
| String[] keyTypes, |
| String[] valueTypes, |
| String mapName, |
| PrintWriter pw, |
| PrintWriter xmlPw, |
| PrintWriter xmlPw1, |
| PrintWriter xmlPw2) { |
| final String[] embeddedKeys = {"", "true", "false"}; |
| final String[] embeddedValues = embeddedKeys; |
| final String[] embeddedKeyForFieldSpec = {"", "embedded-key=true", "embedded-key=false"}; |
| final String[] embeddedValueForFieldSpec = {"", "embedded-value=true", "embedded-value=false"}; |
| |
| int fieldCounter = 0; |
| String[] fieldNames = |
| new String |
| [keyTypes.length * embeddedKeys.length * valueTypes.length * embeddedValues.length]; |
| for (String keyType : keyTypes) { |
| for (int j = 0; j < embeddedKeys.length; j++) { |
| for (String valueType : valueTypes) { |
| for (int l = 0; l < embeddedValues.length; l++) { |
| if (keyType.equals("") |
| && embeddedKeys[j].equals("") |
| && valueType.equals("") |
| && embeddedValues[l].equals("")) continue; |
| fieldNames[fieldCounter] = mapName + "Of" + keyType + "_" + valueType + fieldCounter; |
| pw.println(" public " + mapName + " " + fieldNames[fieldCounter] + ";"); |
| printXmlMapField( |
| xmlPw, |
| fieldNames[fieldCounter], |
| keyType, |
| embeddedKeys[j], |
| valueType, |
| embeddedValues[l]); |
| printXmlMapField( |
| xmlPw1, |
| fieldNames[fieldCounter], |
| keyType, |
| embeddedKeys[j], |
| valueType, |
| embeddedValues[l]); |
| printXmlMapField( |
| xmlPw2, |
| fieldNames[fieldCounter], |
| keyType, |
| embeddedKeys[j], |
| valueType, |
| embeddedValues[l]); |
| buildFieldSpecs( |
| embeddedKeyForFieldSpec[j] |
| + " " |
| + embeddedValueForFieldSpec[l] |
| + " " |
| + "public " |
| + mapName |
| + " " |
| + fieldNames[fieldCounter]); // add to the field specs array*/ |
| fieldCounter++; |
| } |
| } |
| } |
| } |
| writeFieldSpecs(pw); |
| writeMethodGetLength(pw); |
| writeMethodGet(pw, mapName, fieldNames, fieldCounter); |
| writeMethodSet(pw, mapName, fieldNames, fieldCounter); |
| } |
| |
| public static void main(String[] args) { |
| ClassGenerator classGenerator = new ClassGenerator(); |
| try { |
| classGenerator.generate(); |
| classGenerator.generateCollections(); |
| } catch (Exception e) { |
| System.out.println(e); |
| e.printStackTrace(); |
| } |
| } |
| } |
