| /* |
| * |
| * 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 |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| package org.apache.qpid.gentools; |
| |
| import java.io.File; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.TreeMap; |
| |
| public class JavaGenerator extends Generator |
| { |
| // TODO: Move this to parent class |
| protected static final int FIELD_NAME = 0; |
| protected static final int FIELD_CODE_TYPE = 1; |
| |
| private class DomainInfo |
| { |
| final public String type; |
| final public String size; |
| final public String encodingType; |
| final public String encodeExpression; |
| final public String decodeExpression; |
| |
| public DomainInfo(String domain, String size, String encodingType, String encodeExpression, String decodeExpression) |
| { |
| this.type = domain; |
| this.size = size; |
| this.encodeExpression = encodeExpression; |
| this.decodeExpression = decodeExpression; |
| this.encodingType = encodingType; |
| } |
| } |
| |
| private static TreeMap<String, DomainInfo> typeMap = new TreeMap<String, DomainInfo>(); |
| |
| // Methods used for generation of code snippets called from the field map parsers |
| |
| // Common methods |
| private final CommandGenerateMethod declarationGenerateMethod = new CommandGenerateMethod() |
| { |
| public String generate(String codeType, AmqpField field, AmqpVersionSet versionSet, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateFieldDeclaration(codeType, field, versionSet, indentSize, tabSize, notLast); |
| } |
| }; |
| |
| private MangledGenerateMethod mangledDeclarationGenerateMethod = new MangledGenerateMethod() |
| { |
| public String generate(AmqpField field, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateMangledFieldDeclaration(field, indentSize, tabSize, notLast); |
| } |
| }; |
| |
| // Methods for MessageBody classes |
| private CommandGenerateMethod mbGetGenerateMethod = new CommandGenerateMethod() |
| { |
| public String generate(String codeType, AmqpField field, AmqpVersionSet versionSet, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateMbGetMethod(codeType, field, versionSet, indentSize, tabSize, notLast); //To change body of implemented methods use File | Settings | File Templates. |
| } |
| }; |
| |
| private MangledGenerateMethod mbMangledGetGenerateMethod = new MangledGenerateMethod() |
| { |
| public String generate(AmqpField field, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateMbMangledGetMethod(field, indentSize, tabSize, notLast); |
| } |
| }; |
| private CommandGenerateMethod mbParamListGenerateMethod = new CommandGenerateMethod() |
| { |
| public String generate(String codeType, AmqpField field, AmqpVersionSet versionSet, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateMbParamList(codeType, field, versionSet, indentSize, tabSize, notLast); |
| } |
| }; |
| private CommandGenerateMethod mbPassedParamListGenerateMethod = new CommandGenerateMethod() |
| { |
| public String generate(String codeType, AmqpField field, AmqpVersionSet versionSet, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateMbPassedParamList(codeType, field, versionSet, indentSize, tabSize, notLast); |
| } |
| }; |
| private MangledGenerateMethod mbMangledParamListGenerateMethod = new MangledGenerateMethod() |
| { |
| public String generate(AmqpField field, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateMbMangledParamList(field, indentSize, tabSize, notLast); |
| } |
| }; |
| private MangledGenerateMethod mbMangledPassedParamListGenerateMethod = new MangledGenerateMethod() |
| { |
| public String generate(AmqpField field, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateMbMangledPassedParamList(field, indentSize, tabSize, notLast); |
| } |
| }; |
| private CommandGenerateMethod mbBodyInitGenerateMethod = new CommandGenerateMethod() |
| { |
| public String generate(String codeType, AmqpField field, AmqpVersionSet versionSet, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateMbBodyInit(codeType, field, versionSet, indentSize, tabSize, notLast); |
| } |
| }; |
| private MangledGenerateMethod mbMangledBodyInitGenerateMethod = new MangledGenerateMethod() |
| { |
| public String generate(AmqpField field, int indentSize, int tabSize, boolean notLast) |
| { |
| return generateMbMangledBodyInit(field, indentSize, tabSize, notLast); |
| } |
| }; |
| private GenerateMethod mbSizeGenerateMethod = new GenerateMethod() |
| { |
| public String generate(String domainType, String fieldName, int ordinal, int indentSize, int tabSize) |
| { |
| return generateMbFieldSize(domainType, fieldName, ordinal, indentSize, tabSize); |
| } |
| }; |
| private BitFieldGenerateMethod mbBitSizeGenerateMethod = new BitFieldGenerateMethod() |
| { |
| public String generate(List<String> bitFieldList, int ordinal, int indentSize, int tabSize) |
| { |
| return generateMbBitArrayFieldSize(bitFieldList, ordinal, indentSize, tabSize); |
| } |
| }; |
| private GenerateMethod mbEncodeGenerateMethod = new GenerateMethod() |
| { |
| public String generate(String domainType, String fieldName, int ordinal, int indentSize, int tabSize) |
| { |
| return generateMbFieldEncode(domainType, fieldName, ordinal, indentSize, tabSize); |
| } |
| }; |
| private BitFieldGenerateMethod mbBitEncodeGenerateMethod = new BitFieldGenerateMethod() |
| { |
| public String generate(List<String> bitFieldList, int ordinal, int indentSize, int tabSize) |
| { |
| return generateMbBitFieldEncode(bitFieldList, ordinal, indentSize, tabSize); |
| } |
| }; |
| private GenerateMethod mbDecodeGenerateMethod = new GenerateMethod() |
| { |
| public String generate(String domainType, String fieldName, int ordinal, int indentSize, int tabSize) |
| { |
| return generateMbFieldDecode(domainType, fieldName, ordinal, indentSize, tabSize); |
| } |
| }; |
| private BitFieldGenerateMethod mbBitDecodeGenerateMethod = new BitFieldGenerateMethod() |
| { |
| public String generate(List<String> bitFieldList, int ordinal, int indentSize, int tabSize) |
| { |
| return generateMbBitFieldDecode(bitFieldList, ordinal, indentSize, tabSize); |
| } |
| }; |
| private GenerateMethod mbToStringGenerateMethod = new GenerateMethod() |
| { |
| public String generate(String domainType, String fieldName, int ordinal, int indentSize, int tabSize) |
| { |
| return generateMbFieldToString(domainType, fieldName, ordinal, indentSize, tabSize); |
| } |
| }; |
| private BitFieldGenerateMethod mbBitToStringGenerateMethod = new BitFieldGenerateMethod() |
| { |
| public String generate(List<String> bitFieldList, int ordinal, int indentSize, int tabSize) |
| { |
| return generateMbBitFieldToString(bitFieldList, ordinal, indentSize, tabSize); |
| } |
| }; |
| |
| // Methods for PropertyContentHeader classes |
| private CommandGenerateMethod pchClearGenerateMethod = new CommandGenerateMethod() |
| { |
| public String generate(String codeType, AmqpField field, AmqpVersionSet versionSet, int indentSize, int tabSize, boolean notLast) |
| { |
| return generatePchClearMethod(codeType, field, versionSet, indentSize, tabSize, notLast); |
| } |
| }; |
| private MangledGenerateMethod pchMangledClearGenerateMethod = new MangledGenerateMethod() |
| { |
| public String generate(AmqpField field, int indentSize, int tabSize, boolean notLast) |
| { |
| return generatePchMangledClearMethod(field, indentSize, tabSize, notLast); |
| } |
| }; |
| private CommandGenerateMethod pchGetGenerateMethod = new CommandGenerateMethod() |
| { |
| public String generate(String codeType, AmqpField field, AmqpVersionSet versionSet, int indentSize, int tabSize, boolean notLast) |
| { |
| return generatePchGetMethod(codeType, field, versionSet, indentSize, tabSize, notLast); |
| } |
| }; |
| private MangledGenerateMethod pchMangledGetGenerateMethod = new MangledGenerateMethod() |
| { |
| public String generate(AmqpField field, int indentSize, int tabSize, boolean notLast) |
| { |
| return generatePchMangledGetMethod(field, indentSize, tabSize, notLast); |
| } |
| }; |
| private CommandGenerateMethod pchSetGenerateMethod = new CommandGenerateMethod() |
| { |
| public String generate(String codeType, AmqpField field, AmqpVersionSet versionSet, int indentSize, int tabSize, boolean notLast) |
| { |
| return generatePchSetMethod(codeType, field, versionSet, indentSize, tabSize, notLast); |
| } |
| }; |
| private MangledGenerateMethod pchMangledSetGenerateMethod = new MangledGenerateMethod() |
| { |
| public String generate(AmqpField field, int indentSize, int tabSize, boolean notLast) |
| { |
| return generatePchMangledSetMethod(field, indentSize, tabSize, notLast); |
| } |
| }; |
| private GenerateMethod pchSizeGenerateMethod = new GenerateMethod() |
| { |
| public String generate(String domainType, String fieldName, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchFieldSize(domainType, fieldName, ordinal, indentSize, tabSize); |
| } |
| }; |
| private BitFieldGenerateMethod pchBitSizeGenerateMethod = new BitFieldGenerateMethod() |
| { |
| public String generate(List<String> bitFieldList, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchBitArrayFieldSize(bitFieldList, ordinal, indentSize, tabSize); |
| } |
| }; |
| private GenerateMethod pchEncodeGenerateMethod = new GenerateMethod() |
| { |
| public String generate(String domainType, String fieldName, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchFieldEncode(domainType, fieldName, ordinal, indentSize, tabSize); |
| } |
| }; |
| private BitFieldGenerateMethod pchBitEncodeGenerateMethod = new BitFieldGenerateMethod() |
| { |
| public String generate(List<String> bitFieldList, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchBitFieldEncode(bitFieldList, ordinal, indentSize, tabSize); |
| } |
| }; |
| private GenerateMethod pchDecodeGenerateMethod = new GenerateMethod() |
| { |
| public String generate(String domainType, String fieldName, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchFieldDecode(domainType, fieldName, ordinal, indentSize, tabSize); |
| } |
| }; |
| private BitFieldGenerateMethod pchBitDecodeGenerateMethod = new BitFieldGenerateMethod() |
| { |
| public String generate(List<String> bitFieldList, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchBitFieldDecode(bitFieldList, ordinal, indentSize, tabSize); |
| } |
| }; |
| private GenerateMethod pchGetPropertyFlagsGenerateMethod = new GenerateMethod() |
| { |
| public String generate(String domainType, String fieldName, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchGetPropertyFlags(domainType, fieldName, ordinal, indentSize, tabSize); |
| } |
| }; |
| private BitFieldGenerateMethod pchBitGetPropertyFlagsGenerateMethod = new BitFieldGenerateMethod() |
| { |
| public String generate(List<String> bitFieldList, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchBitGetPropertyFlags(bitFieldList, ordinal, indentSize, tabSize); |
| } |
| }; |
| private GenerateMethod pchSetPropertyFlagsGenerateMethod = new GenerateMethod() |
| { |
| public String generate(String domainType, String fieldName, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchSetPropertyFlags(domainType, fieldName, ordinal, indentSize, tabSize); |
| } |
| }; |
| private BitFieldGenerateMethod pchBitSetPropertyFlagsGenerateMethod = new BitFieldGenerateMethod() |
| { |
| public String generate(List<String> bitFieldList, int ordinal, int indentSize, int tabSize) |
| { |
| return generatePchBitSetPropertyFlags(bitFieldList, ordinal, indentSize, tabSize); |
| } |
| }; |
| |
| |
| public String getNativeType(String type) |
| { |
| return typeMap.get(type).type; |
| } |
| |
| public String getEncodingType(String type) |
| { |
| return typeMap.get(type).encodingType; |
| } |
| |
| |
| public JavaGenerator() |
| { |
| super(); |
| // Load Java type and size maps. |
| // Adjust or add to these lists as new types are added/defined. |
| // The char '#' will be replaced by the field variable name (any type). |
| // The char '~' will be replaced by the compacted bit array size (type bit only). |
| typeMap.put("bit", new DomainInfo( |
| "boolean", // Java code type |
| "~", // size |
| "Boolean", // Java code type |
| "EncodingUtils.writeBooleans(buffer, #)", // encode expression |
| "# = EncodingUtils.readBooleans(buffer)")); // decode expression |
| typeMap.put("bitfield", new DomainInfo( |
| "byte", // Java code type |
| "~", // size |
| "Bitfield", |
| "EncodingUtils.writeBooleans(buffer, #)", // encode expression |
| "# = EncodingUtils.readBooleans(buffer)")); // decode expression |
| |
| typeMap.put("content", new DomainInfo( |
| "Content", // Java code type |
| "EncodingUtils.encodedContentLength(#)", // size |
| "Content", // Java code type |
| "EncodingUtils.writeContentBytes(buffer, #)", // encode expression |
| "# = EncodingUtils.readContent(buffer)")); // decode expression |
| typeMap.put("long", new DomainInfo( |
| "long", // Java code type |
| "4", // size |
| "UnsignedInteger", // Java code type |
| "EncodingUtils.writeUnsignedInteger(buffer, #)", // encode expression |
| "# = buffer.getUnsignedInt()")); // decode expression |
| typeMap.put("longlong", new DomainInfo( |
| "long", // Java code type |
| "8", // size |
| "Long", |
| "buffer.putLong(#)", // encode expression |
| "# = buffer.getLong()")); // decode expression |
| typeMap.put("longstr", new DomainInfo( |
| "byte[]", // Java code type |
| "EncodingUtils.encodedLongstrLength(#)", // size |
| "Bytes", |
| "EncodingUtils.writeLongStringBytes(buffer, #)", // encode expression |
| "# = EncodingUtils.readLongstr(buffer)")); // decode expression |
| typeMap.put("octet", new DomainInfo( |
| "short", // Java code type |
| "1", // size |
| "UnsignedByte", |
| "EncodingUtils.writeUnsignedByte(buffer, #)", // encode expression |
| "# = buffer.getUnsigned()")); // decode expression |
| typeMap.put("short", new DomainInfo( |
| "int", // Java code type |
| "2", // size |
| "UnsignedShort", |
| "EncodingUtils.writeUnsignedShort(buffer, #)", // encode expression |
| "# = buffer.getUnsignedShort()")); // decode expression |
| typeMap.put("shortstr", new DomainInfo( |
| "AMQShortString", // Java code type |
| "EncodingUtils.encodedShortStringLength(#)", // size |
| "AMQShortString", // Java code type |
| "EncodingUtils.writeShortStringBytes(buffer, #)", // encode expression |
| "# = EncodingUtils.readAMQShortString(buffer)")); // decode expression |
| typeMap.put("table", new DomainInfo( |
| "FieldTable", // Java code type |
| "EncodingUtils.encodedFieldTableLength(#)", // size |
| "FieldTable", // Java code type |
| "EncodingUtils.writeFieldTableBytes(buffer, #)", // encode expression |
| "# = EncodingUtils.readFieldTable(buffer)")); // decode expression |
| typeMap.put("timestamp", new DomainInfo( |
| "long", // Java code type |
| "8", // size |
| "Timestamp", |
| "EncodingUtils.writeTimestamp(buffer, #)", // encode expression |
| "# = EncodingUtils.readTimestamp(buffer)")); // decode expression |
| } |
| |
| // === Start of methods for Interface LanguageConverter === |
| |
| public String prepareClassName(String className) |
| { |
| return camelCaseName(className, true); |
| } |
| |
| public String prepareMethodName(String methodName) |
| { |
| return camelCaseName(methodName, false); |
| } |
| |
| public String prepareDomainName(String domainName) |
| { |
| return camelCaseName(domainName, false); |
| } |
| |
| |
| public String getGeneratedType(String domainName, AmqpVersion version) |
| { |
| String domainType = getDomainType(domainName, version); |
| if (domainType == null) |
| { |
| throw new AmqpTypeMappingException("Domain type \"" + domainName + |
| "\" not found in Java typemap."); |
| } |
| DomainInfo info = typeMap.get(domainType); |
| if (info == null) |
| { |
| throw new AmqpTypeMappingException("Unknown domain: \"" + domainType + "\""); |
| } |
| return info.type; |
| } |
| |
| // === Abstract methods from class Generator - Java-specific implementations === |
| |
| @Override |
| protected String prepareFilename(String filenameTemplate, AmqpClass thisClass, AmqpMethod method, |
| AmqpField field, AmqpVersion version) |
| { |
| StringBuffer sb = new StringBuffer(filenameTemplate); |
| if (thisClass != null) |
| { |
| replaceToken(sb, "${CLASS}", thisClass.getName()); |
| } |
| if (method != null) |
| { |
| replaceToken(sb, "${METHOD}", method.getName()); |
| } |
| if (field != null) |
| { |
| replaceToken(sb, "${FIELD}", field.getName()); |
| } |
| if (version != null) |
| { |
| replaceToken(sb, "${MAJOR}", String.valueOf(version.getMajor())); |
| replaceToken(sb, "${MINOR}", String.valueOf(version.getMinor())); |
| } |
| return sb.toString(); |
| } |
| |
| @Override |
| protected void processModelTemplate(NamedTemplate template) |
| { |
| processTemplate(template, null, null, null, null); |
| } |
| |
| @Override |
| protected void processClassTemplate(NamedTemplate template, AmqpClass thisClass) |
| { |
| processTemplate(template, thisClass, null, null, |
| thisClass.getVersionSet().size() == 1 ? thisClass.getVersionSet().first() : null); |
| } |
| |
| @Override |
| protected void processMethodTemplate(NamedTemplate template, AmqpClass thisClass, |
| AmqpMethod method) |
| { |
| processTemplate(template, thisClass, method, null, |
| thisClass.getVersionSet().size() == 1 ? thisClass.getVersionSet().first() : null); |
| } |
| |
| protected void processFieldTemplate(NamedTemplate template, AmqpClass thisClass, |
| AmqpMethod method, AmqpField field) |
| { |
| processTemplate(template, thisClass, method, field, |
| thisClass.getVersionSet().size() == 1 ? thisClass.getVersionSet().first() : null); |
| } |
| |
| @Override |
| protected void processTemplate(NamedTemplate template, AmqpClass thisClass, |
| AmqpMethod method, AmqpField field, AmqpVersion version) |
| { |
| StringBuffer sb = new StringBuffer(template.getTemplate()); |
| String filename = prepareFilename(getTemplateFileName(sb), thisClass, method, field, version); |
| processTemplate(sb, thisClass, method, field, template.getName(), version); |
| writeTargetFile(sb, new File(getOutputDirectory() + Utils.FILE_SEPARATOR + filename)); |
| generatedFileCounter++; |
| } |
| |
| protected void processTemplate(StringBuffer sb, AmqpClass thisClass, AmqpMethod method, |
| AmqpField field, String templateFileName, AmqpVersion version) |
| { |
| try |
| { |
| processAllLists(sb, thisClass, method, version); |
| } |
| catch (AmqpTemplateException e) |
| { |
| System.out.println("WARNING: " + templateFileName + ": " + e.getMessage()); |
| } |
| try |
| { |
| processAllTokens(sb, thisClass, method, field, version); |
| } |
| catch (AmqpTemplateException e) |
| { |
| System.out.println("WARNING: " + templateFileName + ": " + e.getMessage()); |
| } |
| } |
| |
| @Override |
| protected String processToken(String token, AmqpClass thisClass, AmqpMethod method, AmqpField field, |
| AmqpVersion version) |
| { |
| if (token.compareTo("${GENERATOR}") == 0) |
| { |
| return GENERATOR_INFO; |
| } |
| if (token.compareTo("${CLASS}") == 0 && thisClass != null) |
| { |
| return thisClass.getName(); |
| } |
| if (token.compareTo("${CLASS_ID_INIT}") == 0 && thisClass != null) |
| { |
| return generateIndexInitializer("registerClassId", thisClass.getIndexMap(), 8); |
| } |
| if (token.compareTo("${METHOD}") == 0 && method != null) |
| { |
| return method.getName(); |
| } |
| if (token.compareTo("${METHOD_ID_INIT}") == 0 && method != null) |
| { |
| return generateIndexInitializer("registerMethodId", method.getIndexMap(), 8); |
| } |
| if (token.compareTo("${FIELD}") == 0 && field != null) |
| { |
| return field.getName(); |
| } |
| |
| // This token is used only with class or method-level templates |
| if (token.compareTo("${pch_property_flags_declare}") == 0) |
| { |
| return generatePchPropertyFlagsDeclare(); |
| } |
| else if (token.compareTo("${pch_property_flags_initializer}") == 0) |
| { |
| int mapSize = method == null ? thisClass.getFieldMap().size() : method.getFieldMap().size(); |
| return generatePchPropertyFlagsInitializer(mapSize); |
| } |
| else if (token.compareTo("${pch_compact_property_flags_initializer}") == 0) |
| { |
| return generatePchCompactPropertyFlagsInitializer(thisClass, 8, 4); |
| } |
| else if (token.compareTo("${pch_compact_property_flags_check}") == 0) |
| { |
| return generatePchCompactPropertyFlagsCheck(thisClass, 8, 4); |
| } |
| |
| // Oops! |
| throw new AmqpTemplateException("Template token " + token + " unknown."); |
| } |
| |
| @Override |
| protected void processClassList(StringBuffer sb, int listMarkerStartIndex, int listMarkerEndIndex, |
| AmqpModel model, AmqpVersion version) |
| { |
| String codeSnippet; |
| int lend = sb.indexOf(CR, listMarkerStartIndex) + 1; // Include cr at end of line |
| String tline = sb.substring(listMarkerEndIndex, lend); // Line excluding line marker, including cr |
| int tokStart = tline.indexOf('$'); |
| String token = tline.substring(tokStart).trim(); |
| sb.delete(listMarkerStartIndex, lend); |
| |
| if (token.compareTo("${reg_map_put_method}") == 0) |
| { |
| codeSnippet = generateRegistry(model, 8, 4); |
| } |
| |
| else // Oops! |
| { |
| throw new AmqpTemplateException("Template token " + token + " unknown."); |
| } |
| |
| sb.insert(listMarkerStartIndex, codeSnippet); |
| } |
| |
| @Override |
| protected void processMethodList(StringBuffer sb, int listMarkerStartIndex, int listMarkerEndIndex, |
| AmqpClass thisClass) |
| { |
| String codeSnippet; |
| int lend = sb.indexOf(CR, listMarkerStartIndex) + 1; // Include cr at end of line |
| String tline = sb.substring(listMarkerEndIndex, lend); // Line excluding line marker, including cr |
| int tokStart = tline.indexOf('$'); |
| String token = tline.substring(tokStart).trim(); |
| sb.delete(listMarkerStartIndex, lend); |
| |
| //TODO - we don't have any cases of this (yet). |
| if (token.compareTo("${???}") == 0) |
| { |
| codeSnippet = token; |
| } |
| else // Oops! |
| { |
| throw new AmqpTemplateException("Template token " + token + " unknown."); |
| } |
| |
| sb.insert(listMarkerStartIndex, codeSnippet); |
| } |
| |
| @Override |
| protected void processFieldList(StringBuffer sb, int listMarkerStartIndex, int listMarkerEndIndex, |
| AmqpFieldMap fieldMap, AmqpVersion version) |
| { |
| String codeSnippet; |
| int lend = sb.indexOf(CR, listMarkerStartIndex) + 1; // Include cr at end of line |
| String tline = sb.substring(listMarkerEndIndex, lend); // Line excluding line marker, including cr |
| int tokStart = tline.indexOf('$'); |
| String token = tline.substring(tokStart).trim(); |
| sb.delete(listMarkerStartIndex, lend); |
| |
| // Field declarations - common to MethodBody and PropertyContentHeader classes |
| if (token.compareTo("${field_declaration}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMap(declarationGenerateMethod, |
| mangledDeclarationGenerateMethod, 4, 4, this); |
| } |
| |
| // MethodBody classes |
| else if (token.compareTo("${mb_field_get_method}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMap(mbGetGenerateMethod, |
| mbMangledGetGenerateMethod, 4, 4, this); |
| } |
| else if (token.compareTo("${mb_field_parameter_list}") == 0) |
| { |
| // <cringe> The code generated by this is ugly... It puts a comma on a line by itself! |
| // TODO: Find a more elegant solution here sometime... |
| codeSnippet = fieldMap.size() > 0 ? Utils.createSpaces(42) + "," + CR : ""; |
| // </cringe> |
| codeSnippet += fieldMap.parseFieldMap(mbParamListGenerateMethod, |
| mbMangledParamListGenerateMethod, 42, 4, this); |
| } |
| |
| else if (token.compareTo("${mb_field_passed_parameter_list}") == 0) |
| { |
| // <cringe> The code generated by this is ugly... It puts a comma on a line by itself! |
| // TODO: Find a more elegant solution here sometime... |
| codeSnippet = fieldMap.size() > 0 ? Utils.createSpaces(42) + "," + CR : ""; |
| // </cringe> |
| codeSnippet += fieldMap.parseFieldMap(mbPassedParamListGenerateMethod, |
| mbMangledPassedParamListGenerateMethod, 42, 4, this); |
| } |
| else if (token.compareTo("${mb_field_body_initialize}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMap(mbBodyInitGenerateMethod, |
| mbMangledBodyInitGenerateMethod, 8, 4, this); |
| } |
| else if (token.compareTo("${mb_field_size}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMapOrdinally(mbSizeGenerateMethod, |
| mbBitSizeGenerateMethod, 8, 4, this); |
| } |
| else if (token.compareTo("${mb_field_encode}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMapOrdinally(mbEncodeGenerateMethod, |
| mbBitEncodeGenerateMethod, 8, 4, this); |
| } |
| else if (token.compareTo("${mb_field_decode}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMapOrdinally(mbDecodeGenerateMethod, |
| mbBitDecodeGenerateMethod, 8, 4, this); |
| } |
| else if (token.compareTo("${mb_field_to_string}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMapOrdinally(mbToStringGenerateMethod, |
| mbBitToStringGenerateMethod, 8, 4, this); |
| } |
| |
| // PropertyContentHeader classes |
| else if (token.compareTo("${pch_field_list_size}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMapOrdinally(pchSizeGenerateMethod, |
| pchBitSizeGenerateMethod, 12, 4, this); |
| } |
| else if (token.compareTo("${pch_field_list_payload}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMapOrdinally(pchEncodeGenerateMethod, |
| pchBitEncodeGenerateMethod, 12, 4, this); |
| } |
| else if (token.compareTo("${pch_field_list_decode}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMapOrdinally(pchDecodeGenerateMethod, |
| pchBitDecodeGenerateMethod, 12, 4, this); |
| } |
| else if (token.compareTo("${pch_get_compact_property_flags}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMapOrdinally(pchGetPropertyFlagsGenerateMethod, |
| pchBitGetPropertyFlagsGenerateMethod, 8, 4, this); |
| } |
| else if (token.compareTo("${pch_set_compact_property_flags}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMapOrdinally(pchSetPropertyFlagsGenerateMethod, |
| pchBitSetPropertyFlagsGenerateMethod, 8, 4, this); |
| } |
| else if (token.compareTo("${pch_field_clear_methods}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMap(pchClearGenerateMethod, |
| pchMangledClearGenerateMethod, 4, 4, this); |
| } |
| else if (token.compareTo("${pch_field_get_methods}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMap(pchGetGenerateMethod, |
| pchMangledGetGenerateMethod, 4, 4, this); |
| } |
| else if (token.compareTo("${pch_field_set_methods}") == 0) |
| { |
| codeSnippet = fieldMap.parseFieldMap(pchSetGenerateMethod, |
| pchMangledSetGenerateMethod, 4, 4, this); |
| } |
| |
| else // Oops! |
| { |
| throw new AmqpTemplateException("Template token " + token + " unknown."); |
| } |
| sb.insert(listMarkerStartIndex, codeSnippet); |
| } |
| |
| @Override |
| protected void processConstantList(StringBuffer sb, int listMarkerStartIndex, int listMarkerEndIndex, |
| AmqpConstantSet constantSet) |
| { |
| String codeSnippet; |
| int lend = sb.indexOf(CR, listMarkerStartIndex) + 1; // Include cr at end of line |
| String tline = sb.substring(listMarkerEndIndex, lend); // Line excluding line marker, including cr |
| int tokStart = tline.indexOf('$'); |
| String token = tline.substring(tokStart).trim(); |
| sb.delete(listMarkerStartIndex, lend); |
| |
| if (token.compareTo("${const_get_method}") == 0) |
| { |
| codeSnippet = generateConstantGetMethods(constantSet, 4, 4); |
| } |
| |
| else // Oops! |
| { |
| throw new AmqpTemplateException("Template token " + token + " unknown."); |
| } |
| |
| sb.insert(listMarkerStartIndex, codeSnippet); |
| } |
| |
| // === Protected and private helper functions unique to Java implementation === |
| |
| // Methods used for generation of code snippets called from the field map parsers |
| |
| // Common methods |
| |
| protected String generateFieldDeclaration(String codeType, AmqpField field, |
| AmqpVersionSet versionSet, int indentSize, int tabSize, boolean nextFlag) |
| { |
| return Utils.createSpaces(indentSize) + "public " + codeType + " " + field.getName() + |
| "; // AMQP version(s): " + versionSet + CR; |
| } |
| |
| protected String generateMangledFieldDeclaration(AmqpField field, int indentSize, |
| int tabSize, boolean nextFlag) |
| { |
| StringBuffer sb = new StringBuffer(); |
| Iterator<String> dItr = field.getDomainMap().keySet().iterator(); |
| int domainCntr = 0; |
| while (dItr.hasNext()) |
| { |
| String domainName = dItr.next(); |
| AmqpVersionSet versionSet = field.getDomainMap().get(domainName); |
| String codeType = getGeneratedType(domainName, versionSet.first()); |
| sb.append(Utils.createSpaces(indentSize) + "public " + codeType + " " + |
| field.getName() + "_" + (domainCntr++) + "; // AMQP Version(s): " + versionSet + |
| CR); |
| } |
| return sb.toString(); |
| } |
| |
| protected String generateIndexInitializer(String mapName, AmqpOrdinalVersionMap indexMap, int indentSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| StringBuffer sb = new StringBuffer(); |
| |
| Iterator<Integer> iItr = indexMap.keySet().iterator(); |
| while (iItr.hasNext()) |
| { |
| int index = iItr.next(); |
| AmqpVersionSet versionSet = indexMap.get(index); |
| Iterator<AmqpVersion> vItr = versionSet.iterator(); |
| while (vItr.hasNext()) |
| { |
| AmqpVersion version = vItr.next(); |
| sb.append(indent + mapName + "( (byte) " + version.getMajor() + ", (byte) " + version.getMinor() + ", " + index + ");" + CR); |
| } |
| } |
| return sb.toString(); |
| } |
| |
| protected String generateRegistry(AmqpModel model, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| |
| for (String className : model.getClassMap().keySet()) |
| { |
| AmqpClass thisClass = model.getClassMap().get(className); |
| for (String methodName : thisClass.getMethodMap().keySet()) |
| { |
| AmqpMethod method = thisClass.getMethodMap().get(methodName); |
| for (AmqpVersion version : model.getVersionSet()) |
| { |
| // Find class and method index for this version (if it exists) |
| try |
| { |
| int classIndex = findIndex(thisClass.getIndexMap(), version); |
| int methodIndex = findIndex(method.getIndexMap(), version); |
| sb.append(indent + "registerMethod(" + CR); |
| sb.append(indent + tab + "(short)" + classIndex + |
| ", (short)" + methodIndex + ", (byte)" + version.getMajor() + |
| ", (byte)" + version.getMinor() + ", " + CR); |
| sb.append(indent + tab + Utils.firstUpper(thisClass.getName()) + |
| Utils.firstUpper(method.getName()) + "Body.getFactory());" + CR); |
| } |
| catch (Exception e) |
| { |
| } // Ignore |
| } |
| } |
| } |
| return sb.toString(); |
| } |
| |
| protected int findIndex(TreeMap<Integer, AmqpVersionSet> map, AmqpVersion version) |
| { |
| Iterator<Integer> iItr = map.keySet().iterator(); |
| while (iItr.hasNext()) |
| { |
| int index = iItr.next(); |
| AmqpVersionSet versionSet = map.get(index); |
| if (versionSet.contains(version)) |
| { |
| return index; |
| } |
| } |
| throw new IllegalArgumentException("Index not found"); |
| } |
| |
| // Methods for AmqpConstants class |
| |
| |
| public String prepareConstantName(String constantName) |
| { |
| return upperCaseName(constantName); |
| } |
| |
| |
| protected String generateConstantGetMethods(AmqpConstantSet constantSet, |
| int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| StringBuffer sb = new StringBuffer(); |
| |
| for (AmqpConstant constant : constantSet.getContstants()) |
| { |
| |
| if (constant.isVersionConsistent(constantSet.getVersionSet())) |
| { |
| // return a constant |
| String value = constant.firstKey(); |
| if (Utils.containsOnlyDigits(value)) |
| { |
| sb.append(indent + "public static final int " + constant.getName() + " = " + |
| constant.firstKey() + ";" + CR); |
| } |
| else if (Utils.containsOnlyDigitsAndDecimal(value)) |
| { |
| sb.append(indent + "public static double " + constant.getName() + " = " + |
| constant.firstKey() + "; " + CR); |
| } |
| else |
| { |
| sb.append(indent + "public static String " + constant.getName() + " = " + |
| constant.firstKey() + "\"; " + CR); |
| |
| } |
| sb.append(CR); |
| } |
| else |
| { |
| // Return version-specific constant |
| sb.append(generateVersionDependentGet(constant, "String", "", "\"", "\"", indentSize, tabSize)); |
| sb.append(generateVersionDependentGet(constant, "int", "AsInt", "", "", indentSize, tabSize)); |
| sb.append(generateVersionDependentGet(constant, "double", "AsDouble", "(double)", "", indentSize, tabSize)); |
| sb.append(CR); |
| } |
| } |
| return sb.toString(); |
| } |
| |
| protected String generateVersionDependentGet(AmqpConstant constant, |
| String methodReturnType, String methodNameSuffix, String returnPrefix, String returnPostfix, |
| int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| sb.append(indent + "public static " + methodReturnType + " " + constant.getName() + |
| methodNameSuffix + "(byte major, byte minor) throws AMQProtocolVersionException" + CR); |
| sb.append(indent + "{" + CR); |
| boolean first = true; |
| Iterator<String> sItr = constant.keySet().iterator(); |
| while (sItr.hasNext()) |
| { |
| String value = sItr.next(); |
| AmqpVersionSet versionSet = constant.get(value); |
| sb.append(indent + tab + (first ? "" : "else ") + "if (" + generateVersionCheck(versionSet) + |
| ")" + CR); |
| sb.append(indent + tab + "{" + CR); |
| if (methodReturnType.compareTo("int") == 0 && !Utils.containsOnlyDigits(value)) |
| { |
| sb.append(generateConstantDeclarationException(constant.getName(), methodReturnType, |
| indentSize + (2 * tabSize), tabSize)); |
| } |
| else if (methodReturnType.compareTo("double") == 0 && !Utils.containsOnlyDigitsAndDecimal(value)) |
| { |
| sb.append(generateConstantDeclarationException(constant.getName(), methodReturnType, |
| indentSize + (2 * tabSize), tabSize)); |
| } |
| else |
| { |
| sb.append(indent + tab + tab + "return " + returnPrefix + value + returnPostfix + ";" + CR); |
| } |
| sb.append(indent + tab + "}" + CR); |
| first = false; |
| } |
| sb.append(indent + tab + "else" + CR); |
| sb.append(indent + tab + "{" + CR); |
| sb.append(indent + tab + tab + "throw new AMQProtocolVersionException(\"Constant \\\"" + |
| constant.getName() + "\\\" \" +" + CR); |
| sb.append(indent + tab + tab + tab + |
| "\"is undefined for AMQP version \" + major + \"-\" + minor + \".\");" + CR); |
| sb.append(indent + tab + "}" + CR); |
| sb.append(indent + "}" + CR); |
| return sb.toString(); |
| } |
| |
| protected String generateConstantDeclarationException(String name, String methodReturnType, |
| int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| sb.append(indent + "throw new AMQProtocolVersionException(\"Constant \\\"" + |
| name + "\\\" \" +" + CR); |
| sb.append(indent + tab + "\"cannot be converted to type " + methodReturnType + |
| " for AMQP version \" + major + \"-\" + minor + \".\");" + CR); |
| return sb.toString(); |
| } |
| |
| // Methods for MessageBody classes |
| protected String generateMbGetMethod(String codeType, AmqpField field, |
| AmqpVersionSet versionSet, int indentSize, int tabSize, boolean nextFlag) |
| { |
| return Utils.createSpaces(indentSize) + "public " + codeType + " get" + |
| Utils.firstUpper(field.getName()) + "() { return " + field.getName() + "; }" + |
| CR; |
| } |
| |
| protected String generateMbMangledGetMethod(AmqpField field, int indentSize, |
| int tabSize, boolean nextFlag) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(CR); |
| sb.append(indent + "public <T> T get" + Utils.firstUpper(field.getName()) + |
| "(Class<T> classObj) throws AMQProtocolVersionException" + CR); |
| sb.append(indent + "{" + CR); |
| Iterator<String> dItr = field.getDomainMap().keySet().iterator(); |
| int domainCntr = 0; |
| while (dItr.hasNext()) |
| { |
| String domainName = dItr.next(); |
| AmqpVersionSet versionSet = field.getDomainMap().get(domainName); |
| String codeType = getGeneratedType(domainName, versionSet.first()); |
| sb.append(indent + tab + "if (classObj.equals(" + codeType + |
| ".class)) // AMQP Version(s): " + versionSet + CR); |
| sb.append(indent + tab + tab + "return (T)(Object)" + field.getName() + "_" + |
| (domainCntr++) + ";" + CR); |
| } |
| sb.append(indent + tab + |
| "throw new AMQProtocolVersionException(\"None of the AMQP versions defines \" +" + |
| CR + " \"field \\\"" + field.getName() + |
| "\\\" as domain \\\"\" + classObj.getName() + \"\\\".\");" + CR); |
| sb.append(indent + "}" + CR); |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generateMbParamList(String codeType, AmqpField field, |
| AmqpVersionSet versionSet, int indentSize, int tabSize, boolean nextFlag) |
| { |
| return Utils.createSpaces(indentSize) + codeType + " " + field.getName() + |
| (nextFlag ? "," : "") + " // AMQP version(s): " + versionSet + CR; |
| } |
| |
| |
| protected String generateMbPassedParamList(String codeType, AmqpField field, |
| AmqpVersionSet versionSet, int indentSize, int tabSize, boolean nextFlag) |
| { |
| return Utils.createSpaces(indentSize) + field.getName() + |
| (nextFlag ? "," : "") + " // AMQP version(s): " + versionSet + CR; |
| } |
| |
| |
| protected String generateMbMangledParamList(AmqpField field, int indentSize, |
| int tabSize, boolean nextFlag) |
| { |
| StringBuffer sb = new StringBuffer(); |
| Iterator<String> dItr = field.getDomainMap().keySet().iterator(); |
| int domainCntr = 0; |
| while (dItr.hasNext()) |
| { |
| String domainName = dItr.next(); |
| AmqpVersionSet versionSet = field.getDomainMap().get(domainName); |
| String codeType = getGeneratedType(domainName, versionSet.first()); |
| sb.append(Utils.createSpaces(indentSize) + codeType + " " + field.getName() + "_" + |
| (domainCntr++) + (nextFlag ? "," : "") + " // AMQP version(s): " + |
| versionSet + CR); |
| } |
| return sb.toString(); |
| } |
| |
| protected String generateMbMangledPassedParamList(AmqpField field, int indentSize, |
| int tabSize, boolean nextFlag) |
| { |
| StringBuffer sb = new StringBuffer(); |
| Iterator<String> dItr = field.getDomainMap().keySet().iterator(); |
| int domainCntr = 0; |
| while (dItr.hasNext()) |
| { |
| String domainName = dItr.next(); |
| AmqpVersionSet versionSet = field.getDomainMap().get(domainName); |
| sb.append(Utils.createSpaces(indentSize) + field.getName() + "_" + |
| (domainCntr++) + (nextFlag ? "," : "") + " // AMQP version(s): " + |
| versionSet + CR); |
| } |
| return sb.toString(); |
| } |
| |
| |
| protected String generateMbBodyInit(String codeType, AmqpField field, |
| AmqpVersionSet versionSet, int indentSize, int tabSize, boolean nextFlag) |
| { |
| return Utils.createSpaces(indentSize) + "this." + field.getName() + " = " + field.getName() + |
| ";" + CR; |
| } |
| |
| protected String generateMbMangledBodyInit(AmqpField field, int indentSize, |
| int tabSize, boolean nextFlag) |
| { |
| StringBuffer sb = new StringBuffer(); |
| Iterator<String> dItr = field.getDomainMap().keySet().iterator(); |
| int domainCntr = 0; |
| while (dItr.hasNext()) |
| { |
| dItr.next(); |
| sb.append(Utils.createSpaces(indentSize) + "this." + field.getName() + "_" + domainCntr + |
| " = " + field.getName() + "_" + (domainCntr++) + ";" + CR); |
| } |
| return sb.toString(); |
| } |
| |
| protected String generateMbFieldSize(String domainType, String fieldName, |
| int ordinal, int indentSize, int tabSize) |
| { |
| StringBuffer sb = new StringBuffer(); |
| sb.append(Utils.createSpaces(indentSize) + "size += " + |
| typeMap.get(domainType).size.replaceAll("#", fieldName) + |
| "; // " + fieldName + ": " + domainType + CR); |
| return sb.toString(); |
| } |
| |
| protected String generateMbBitArrayFieldSize(List<String> bitFieldList, |
| int ordinal, int indentSize, int tabSize) |
| { |
| StringBuffer sb = new StringBuffer(); |
| int numBytes = ((bitFieldList.size() - 1) / 8) + 1; |
| String comment = bitFieldList.size() == 1 ? |
| bitFieldList.get(0) + ": bit" : |
| "Combinded bits: " + bitFieldList; |
| sb.append(Utils.createSpaces(indentSize) + "size += " + |
| typeMap.get("bit").size.replaceAll("~", String.valueOf(numBytes)) + |
| "; // " + comment + CR); |
| return sb.toString(); |
| } |
| |
| protected String generateMbFieldEncode(String domain, String fieldName, |
| int ordinal, int indentSize, int tabSize) |
| { |
| StringBuffer sb = new StringBuffer(); |
| sb.append(Utils.createSpaces(indentSize) + |
| typeMap.get(domain).encodeExpression.replaceAll("#", fieldName) + |
| "; // " + fieldName + ": " + domain + CR); |
| return sb.toString(); |
| } |
| |
| protected String generateMbBitFieldEncode(List<String> bitFieldList, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| |
| StringBuilder sb = new StringBuilder(); |
| int i = 0; |
| while (i < bitFieldList.size()) |
| { |
| |
| StringBuilder line = new StringBuilder(); |
| |
| for (int j = 0; i < bitFieldList.size() && j < 8; i++, j++) |
| { |
| if (j != 0) |
| { |
| line.append(", "); |
| } |
| line.append(bitFieldList.get(i)); |
| } |
| |
| sb.append(indent + |
| typeMap.get("bit").encodeExpression.replaceAll("#", line.toString()) + ";" + CR); |
| } |
| return sb.toString(); |
| } |
| |
| protected String generateMbFieldDecode(String domain, String fieldName, |
| int ordinal, int indentSize, int tabSize) |
| { |
| StringBuffer sb = new StringBuffer(); |
| sb.append(Utils.createSpaces(indentSize) + |
| typeMap.get(domain).decodeExpression.replaceAll("#", fieldName) + |
| "; // " + fieldName + ": " + domain + CR); |
| return sb.toString(); |
| } |
| |
| protected String generateMbBitFieldDecode(List<String> bitFieldList, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| |
| StringBuilder sb = new StringBuilder(indent); |
| sb.append("byte packedValue;"); |
| sb.append(CR); |
| |
| // RG HERE! |
| |
| int i = 0; |
| while (i < bitFieldList.size()) |
| { |
| sb.append(indent + "packedValue = EncodingUtils.readByte(buffer);" + CR); |
| |
| for (int j = 0; i < bitFieldList.size() && j < 8; i++, j++) |
| { |
| sb.append(indent + bitFieldList.get(i) + " = ( packedValue & (byte) (1 << " + j + ") ) != 0;" + CR); |
| } |
| } |
| return sb.toString(); |
| } |
| |
| protected String generateMbFieldToString(String domain, String fieldName, |
| int ordinal, int indentSize, int tabSize) |
| { |
| StringBuffer sb = new StringBuffer(); |
| sb.append(Utils.createSpaces(indentSize) + |
| "buf.append(\" " + fieldName + ": \" + " + fieldName + ");" + CR); |
| return sb.toString(); |
| } |
| |
| protected String generateMbBitFieldToString(List<String> bitFieldList, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| StringBuffer sb = new StringBuffer(); |
| for (int i = 0; i < bitFieldList.size(); i++) |
| { |
| String bitFieldName = bitFieldList.get(i); |
| sb.append(indent + "buf.append(\" " + bitFieldName + ": \" + " + bitFieldName + |
| ");" + CR); |
| } |
| return sb.toString(); |
| } |
| |
| // Methods for PropertyContentHeader classes |
| |
| protected String generatePchClearMethod(String codeType, AmqpField field, |
| AmqpVersionSet versionSet, int indentSize, int tabSize, boolean nextFlag) |
| { |
| // This is one case where the ordinal info is the only significant factor, |
| // the domain info plays no part. Defer to the mangled version; the code would be |
| // identical anyway... |
| return generatePchMangledClearMethod(field, indentSize, tabSize, nextFlag); |
| } |
| |
| protected String generatePchMangledClearMethod(AmqpField field, int indentSize, |
| int tabSize, boolean nextFlag) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| sb.append(indent + "public void clear" + Utils.firstUpper(field.getName()) + |
| "()" + CR); |
| sb.append(indent + "{" + CR); |
| |
| // If there is more than one ordinal for this field or the ordinal does not |
| // apply to all known versions, then we need to generate version checks so |
| // we know which fieldProperty to clear. |
| if (field.getOrdinalMap().size() == 1 && |
| field.getOrdinalMap().get(field.getOrdinalMap().firstKey()).size() == field.getVersionSet().size()) |
| { |
| int ordinal = field.getOrdinalMap().firstKey(); |
| sb.append(indent + tab + "clearEncodedForm();" + CR); |
| sb.append(indent + tab + "propertyFlags[" + ordinal + "] = false;" + CR); |
| } |
| else |
| { |
| Iterator<Integer> oItr = field.getOrdinalMap().keySet().iterator(); |
| while (oItr.hasNext()) |
| { |
| int ordinal = oItr.next(); |
| AmqpVersionSet versionSet = field.getOrdinalMap().get(ordinal); |
| sb.append(indent + tab); |
| if (ordinal != field.getOrdinalMap().firstKey()) |
| { |
| sb.append("else "); |
| } |
| sb.append("if ("); |
| sb.append(generateVersionCheck(versionSet)); |
| sb.append(")" + CR); |
| sb.append(indent + tab + "{" + CR); |
| sb.append(indent + tab + tab + "clearEncodedForm();" + CR); |
| sb.append(indent + tab + tab + "propertyFlags[" + ordinal + "] = false;" + CR); |
| sb.append(indent + tab + "}" + CR); |
| } |
| } |
| sb.append(indent + "}" + CR); |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchGetMethod(String codeType, AmqpField field, |
| AmqpVersionSet versionSet, int indentSize, int tabSize, boolean nextFlag) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(indent + "public " + codeType + " get" + |
| Utils.firstUpper(field.getName()) + "()" + CR); |
| sb.append(indent + "{" + CR); |
| sb.append(indent + tab + "decodeIfNecessary();" + CR); |
| sb.append(indent + tab + "return " + field.getName() + ";" + CR); |
| sb.append(indent + "}" + CR); |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchMangledGetMethod(AmqpField field, int indentSize, |
| int tabSize, boolean nextFlag) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(indent + "public <T> T get" + |
| Utils.firstUpper(field.getName()) + |
| "(Class<T> classObj) throws AMQProtocolVersionException" + CR); |
| sb.append(indent + "{" + CR); |
| Iterator<String> dItr = field.getDomainMap().keySet().iterator(); |
| int domainCntr = 0; |
| while (dItr.hasNext()) |
| { |
| String domainName = dItr.next(); |
| AmqpVersionSet versionSet = field.getDomainMap().get(domainName); |
| String codeType = getGeneratedType(domainName, versionSet.first()); |
| sb.append(indent + tab + "if (classObj.equals(" + codeType + |
| ".class)) // AMQP Version(s): " + versionSet + CR); |
| sb.append(indent + tab + "{" + CR); |
| sb.append(indent + tab + tab + "decodeIfNecessary();" + CR); |
| sb.append(indent + tab + tab + "return (T)(Object)" + field.getName() + "_" + |
| (domainCntr++) + ";" + CR); |
| sb.append(indent + tab + "}" + CR); |
| } |
| sb.append(indent + tab + |
| "throw new AMQProtocolVersionException(\"None of the AMQP versions defines \" +" + |
| CR + " \"field \\\"" + field.getName() + |
| "\\\" as domain \\\"\" + classObj.getName() + \"\\\".\");" + CR); |
| sb.append(indent + "}" + CR); |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchSetMethod(String codeType, AmqpField field, |
| AmqpVersionSet versionSet, int indentSize, int tabSize, boolean nextFlag) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| sb.append(indent + "public void set" + Utils.firstUpper(field.getName()) + |
| "(" + codeType + " " + field.getName() + ")" + CR); |
| sb.append(indent + "{" + CR); |
| |
| // If there is more than one ordinal for this field or the ordinal does not |
| // apply to all known versions, then we need to generate version checks so |
| // we know which fieldProperty to clear. |
| if (field.getOrdinalMap().size() == 1 && |
| field.getOrdinalMap().get(field.getOrdinalMap().firstKey()).size() == field.getVersionSet().size()) |
| { |
| int ordinal = field.getOrdinalMap().firstKey(); |
| sb.append(indent + tab + "clearEncodedForm();" + CR); |
| sb.append(indent + tab + "propertyFlags[" + ordinal + "] = true;" + CR); |
| sb.append(indent + tab + "this." + field.getName() + " = " + field.getName() + ";" + CR); |
| } |
| else |
| { |
| Iterator<Integer> oItr = field.getOrdinalMap().keySet().iterator(); |
| while (oItr.hasNext()) |
| { |
| int ordinal = oItr.next(); |
| AmqpVersionSet oVersionSet = field.getOrdinalMap().get(ordinal); |
| sb.append(indent + tab); |
| if (ordinal != field.getOrdinalMap().firstKey()) |
| { |
| sb.append("else "); |
| } |
| sb.append("if ("); |
| sb.append(generateVersionCheck(oVersionSet)); |
| sb.append(")" + CR); |
| sb.append(indent + tab + "{" + CR); |
| sb.append(indent + tab + tab + "clearEncodedForm();" + CR); |
| sb.append(indent + tab + tab + "propertyFlags[" + ordinal + "] = true;" + CR); |
| sb.append(indent + tab + tab + "this." + field.getName() + " = " + field.getName() + ";" + CR); |
| sb.append(indent + tab + "}" + CR); |
| } |
| } |
| sb.append(indent + "}" + CR); |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchMangledSetMethod(AmqpField field, int indentSize, |
| int tabSize, boolean nextFlag) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| |
| Iterator<String> dItr = field.getDomainMap().keySet().iterator(); |
| int domainCntr = 0; |
| while (dItr.hasNext()) |
| { |
| String domainName = dItr.next(); |
| AmqpVersionSet versionSet = field.getDomainMap().get(domainName); |
| String codeType = getGeneratedType(domainName, versionSet.first()); |
| |
| // Find ordinal with matching version |
| AmqpVersionSet commonVersionSet = new AmqpVersionSet(); |
| Iterator<Integer> oItr = field.getOrdinalMap().keySet().iterator(); |
| while (oItr.hasNext()) |
| { |
| int ordinal = oItr.next(); |
| AmqpVersionSet oVersionSet = field.getOrdinalMap().get(ordinal); |
| Iterator<AmqpVersion> vItr = oVersionSet.iterator(); |
| boolean first = true; |
| while (vItr.hasNext()) |
| { |
| AmqpVersion thisVersion = vItr.next(); |
| if (versionSet.contains(thisVersion)) |
| { |
| commonVersionSet.add(thisVersion); |
| } |
| } |
| if (!commonVersionSet.isEmpty()) |
| { |
| sb.append(indent + "public void set" + Utils.firstUpper(field.getName()) + |
| "(" + codeType + " " + field.getName() + ")" + CR); |
| sb.append(indent + "{" + CR); |
| sb.append(indent + tab); |
| if (!first) |
| { |
| sb.append("else "); |
| } |
| sb.append("if ("); |
| sb.append(generateVersionCheck(commonVersionSet)); |
| sb.append(")" + CR); |
| sb.append(indent + tab + "{" + CR); |
| sb.append(indent + tab + tab + "clearEncodedForm();" + CR); |
| sb.append(indent + tab + tab + "propertyFlags[" + ordinal + "] = true;" + CR); |
| sb.append(indent + tab + tab + "this." + field.getName() + "_" + (domainCntr++) + |
| " = " + field.getName() + ";" + CR); |
| sb.append(indent + tab + "}" + CR); |
| sb.append(indent + "}" + CR); |
| sb.append(CR); |
| first = false; |
| } |
| } |
| } |
| return sb.toString(); |
| } |
| |
| protected String generatePchFieldSize(String domainType, String fieldName, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| StringBuffer sb = new StringBuffer(indent + "if (propertyFlags[" + ordinal + "]) // " + |
| fieldName + ": " + domainType + CR); |
| sb.append(indent + Utils.createSpaces(tabSize) + "size += " + |
| typeMap.get(domainType).size.replaceAll("#", fieldName) + ";" + CR); |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchBitArrayFieldSize(List<String> bitFieldList, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| String comment = bitFieldList.size() == 1 ? |
| bitFieldList.get(0) + ": bit" : |
| "Combinded bits: " + bitFieldList; |
| StringBuffer sb = new StringBuffer(); |
| |
| if (bitFieldList.size() == 1) // single bit |
| { |
| sb.append(indent + "if (propertyFlags[" + (ordinal - 1) + "]) // " + comment + CR); |
| sb.append(indent + tab + "size += " + |
| typeMap.get("bit").size.replaceAll("~", "1") + ";" + CR); |
| } |
| else // multiple bits - up to 8 are combined into one byte |
| { |
| String bitCntrName = "bitCntr_" + ordinal; |
| int startOrdinal = ordinal - bitFieldList.size(); |
| sb.append(indent + "// " + comment + CR); |
| sb.append(indent + "int " + bitCntrName + " = 0;" + CR); |
| sb.append(indent + "for (int i=" + startOrdinal + "; i<" + ordinal + "; i++)" + CR); |
| sb.append(indent + "{" + CR); |
| sb.append(indent + tab + "if (propertyFlags[i])" + CR); |
| sb.append(indent + tab + tab + bitCntrName + "++;" + CR); |
| sb.append(indent + "}" + CR); |
| sb.append(indent + "size += " + |
| typeMap.get("bit").size.replaceAll("~", bitCntrName + |
| " > 0 ? ((" + bitCntrName + " - 1) / 8) + 1 : 0") + ";" + CR); |
| } |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchFieldEncode(String domainType, String fieldName, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| StringBuffer sb = new StringBuffer(); |
| sb.append(indent + "if (propertyFlags[" + ordinal + "]) // " + fieldName + ": " + |
| domainType + CR); |
| sb.append(indent + Utils.createSpaces(tabSize) + |
| typeMap.get(domainType).encodeExpression.replaceAll("#", fieldName) + ";" + CR); |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchBitFieldEncode(List<String> bitFieldList, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| String comment = bitFieldList.size() == 1 ? |
| bitFieldList.get(0) + ": bit" : |
| "Combinded bits: " + bitFieldList; |
| StringBuffer sb = new StringBuffer(); |
| |
| if (bitFieldList.size() == 1) // single bit |
| { |
| sb.append(indent + "if (propertyFlags[" + (ordinal - 1) + "]) // " + |
| bitFieldList.get(0) + ": bit" + CR); |
| sb.append(indent + tab + typeMap.get("bit").encodeExpression.replaceAll("#", |
| "new boolean[] {" + bitFieldList.get(0) + "}") + ";" + CR); |
| } |
| else // multiple bits - up to 8 are combined into one byte |
| { |
| int startOrdinal = ordinal - bitFieldList.size(); |
| String bitCntrName = "bitCntr" + startOrdinal; |
| sb.append(indent + "// " + comment + CR); |
| sb.append(indent + "int " + bitCntrName + " = 0;" + CR); |
| sb.append(indent + "for (int i=" + startOrdinal + "; i<=" + (ordinal - 1) + "; i++)" + CR); |
| sb.append(indent + "{" + CR); |
| sb.append(indent + tab + "if (propertyFlags[i])" + CR); |
| sb.append(indent + tab + tab + bitCntrName + "++;" + CR); |
| sb.append(indent + "}" + CR); |
| sb.append(indent + "if (" + bitCntrName + " > 0) // Are any of the property bits set?" + CR); |
| sb.append(indent + "{" + CR); |
| sb.append(indent + tab + "boolean[] fullBitArray = new boolean[] { "); |
| for (int i = 0; i < bitFieldList.size(); i++) |
| { |
| if (i != 0) |
| { |
| sb.append(", "); |
| } |
| sb.append(bitFieldList.get(i)); |
| } |
| sb.append(" };" + CR); |
| sb.append(indent + tab + "boolean[] flaggedBitArray = new boolean[" + bitCntrName + |
| "];" + CR); |
| sb.append(indent + tab + bitCntrName + " = 0;" + CR); |
| sb.append(indent + tab + "for (int i=" + startOrdinal + "; i<=" + (ordinal - 1) + |
| "; i++)" + CR); |
| sb.append(indent + tab + "{" + CR); |
| sb.append(indent + tab + tab + "if (propertyFlags[i])" + CR); |
| sb.append(indent + tab + tab + tab + "flaggedBitArray[" + bitCntrName + |
| "++] = fullBitArray[i];" + CR); |
| sb.append(indent + tab + "}" + CR); |
| sb.append(indent + tab + typeMap.get("bit").encodeExpression.replaceAll("#", |
| "flaggedBitArray") + ";" + CR); |
| sb.append(indent + "}" + CR); |
| } |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchFieldDecode(String domainType, String fieldName, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| StringBuffer sb = new StringBuffer(); |
| sb.append(indent + "if (propertyFlags[" + ordinal + "]) // " + fieldName + ": " + |
| domainType + CR); |
| sb.append(indent + Utils.createSpaces(tabSize) + |
| typeMap.get(domainType).decodeExpression.replaceAll("#", fieldName) + ";" + CR); |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchBitFieldDecode(List<String> bitFieldList, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| String comment = bitFieldList.size() == 1 ? |
| bitFieldList.get(0) + ": bit" : |
| "Combinded bits: " + bitFieldList; |
| StringBuffer sb = new StringBuffer(); |
| |
| if (bitFieldList.size() == 1) // single bit |
| { |
| sb.append(indent + "if (propertyFlags[" + (ordinal - 1) + "]) // " + |
| bitFieldList.get(0) + ": bit" + CR); |
| sb.append(indent + "{" + CR); |
| sb.append(indent + tab + typeMap.get("bit").decodeExpression.replaceAll("#", |
| "boolean[] flaggedBitArray") + ";" + CR); |
| sb.append(indent + tab + bitFieldList.get(0) + " = flaggedBitArray[0];" + CR); |
| sb.append(indent + "}" + CR); |
| } |
| else // multiple bits - up to 8 are combined into one byte |
| { |
| int startOrdinal = ordinal - bitFieldList.size(); |
| String bitCntr = "bitCntr" + startOrdinal; |
| sb.append(indent + "// " + comment + CR); |
| sb.append(indent + "int " + bitCntr + " = 0;" + CR); |
| sb.append(indent + "for (int i=" + startOrdinal + "; i<=" + (ordinal - 1) + "; i++)" + CR); |
| sb.append(indent + "{" + CR); |
| sb.append(indent + tab + "if (propertyFlags[i])" + CR); |
| sb.append(indent + tab + tab + bitCntr + "++;" + CR); |
| sb.append(indent + "}" + CR); |
| sb.append(indent + "if (" + bitCntr + " > 0) // Are any of the property bits set?" + CR); |
| sb.append(indent + "{" + CR); |
| sb.append(indent + tab + typeMap.get("bit").decodeExpression.replaceAll("#", |
| "boolean[] flaggedBitArray") + ";" + CR); |
| sb.append(indent + tab + bitCntr + " = 0;" + CR); |
| for (int i = 0; i < bitFieldList.size(); i++) |
| { |
| sb.append(indent + tab + "if (propertyFlags[" + (startOrdinal + i) + "])" + CR); |
| sb.append(indent + tab + tab + bitFieldList.get(i) + " = flaggedBitArray[" + |
| bitCntr + "++];" + CR); |
| } |
| sb.append(indent + "}" + CR); |
| } |
| |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchGetPropertyFlags(String domainType, String fieldName, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| int word = ordinal / 15; |
| int bit = 15 - (ordinal % 15); |
| sb.append(indent + "if (propertyFlags[" + ordinal + "]) // " + fieldName + ": " + |
| domainType + CR); |
| sb.append(indent + tab + "compactPropertyFlags[" + word + "] |= (1 << " + |
| bit + ");" + CR); |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchBitGetPropertyFlags(List<String> bitFieldList, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| int startOrdinal = ordinal - bitFieldList.size(); |
| |
| for (int i = 0; i < bitFieldList.size(); i++) |
| { |
| int thisOrdinal = startOrdinal + i; |
| int word = thisOrdinal / 15; |
| int bit = 15 - (thisOrdinal % 15); |
| sb.append(indent + "if (propertyFlags[" + thisOrdinal + "])" + CR); |
| sb.append(indent + tab + "compactPropertyFlags[" + word + |
| "] |= (1 << " + bit + ");" + CR); |
| } |
| |
| sb.append(CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchSetPropertyFlags(String domainType, String fieldName, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| StringBuffer sb = new StringBuffer(); |
| int word = ordinal / 15; |
| int bit = 15 - (ordinal % 15); |
| sb.append(indent + "propertyFlags[" + ordinal + "] = (compactPropertyFlags[" + |
| word + "] & (1 << " + bit + ")) > 0;" + CR); |
| return sb.toString(); |
| } |
| |
| protected String generatePchBitSetPropertyFlags(List<String> bitFieldList, |
| int ordinal, int indentSize, int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| StringBuffer sb = new StringBuffer(); |
| int startOrdinal = ordinal - bitFieldList.size(); |
| |
| for (int i = 0; i < bitFieldList.size(); i++) |
| { |
| int thisOrdinal = startOrdinal + i; |
| int word = thisOrdinal / 15; |
| int bit = 15 - (thisOrdinal % 15); |
| sb.append(indent + "propertyFlags[" + thisOrdinal + "] = (compactPropertyFlags[" + |
| word + "] & (1 << " + bit + ")) > 0;" + CR); |
| } |
| return sb.toString(); |
| } |
| |
| private String generatePchPropertyFlagsDeclare() |
| { |
| return "private boolean[] propertyFlags;"; |
| } |
| |
| private String generatePchPropertyFlagsInitializer(int totNumFields) |
| { |
| return "propertyFlags = new boolean[" + totNumFields + "];"; |
| } |
| |
| private String generatePchCompactPropertyFlagsInitializer(AmqpClass thisClass, int indentSize, |
| int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| Iterator<AmqpVersion> vItr = thisClass.getVersionSet().iterator(); |
| while (vItr.hasNext()) |
| { |
| AmqpVersion version = vItr.next(); |
| int numBytes = ((thisClass.getFieldMap().getNumFields(version) - 1) / 15) + 1; |
| |
| sb.append(indent); |
| if (!version.equals(thisClass.getVersionSet().first())) |
| { |
| sb.append("else "); |
| } |
| sb.append("if ( major == " + version.getMajor() + " && minor == " + |
| version.getMinor() + " )" + CR); |
| sb.append(indent + tab + "compactPropertyFlags = new int[] { "); |
| for (int i = 0; i < numBytes; i++) |
| { |
| if (i != 0) |
| { |
| sb.append(", "); |
| } |
| sb.append(i < numBytes - 1 ? "1" : "0"); // Set the "continue" flag where required |
| } |
| sb.append(" };" + CR); |
| } |
| return sb.toString(); |
| } |
| |
| private String generatePchCompactPropertyFlagsCheck(AmqpClass thisClass, int indentSize, |
| int tabSize) |
| { |
| String indent = Utils.createSpaces(indentSize); |
| String tab = Utils.createSpaces(tabSize); |
| StringBuffer sb = new StringBuffer(); |
| Iterator<AmqpVersion> vItr = thisClass.getVersionSet().iterator(); |
| while (vItr.hasNext()) |
| { |
| AmqpVersion version = vItr.next(); |
| int numFields = thisClass.getFieldMap().getNumFields(version); |
| int numBytes = ((numFields - 1) / 15) + 1; |
| |
| sb.append(indent); |
| if (!version.equals(thisClass.getVersionSet().first())) |
| { |
| sb.append("else "); |
| } |
| sb.append("if ( major == " + version.getMajor() + " && minor == " + |
| version.getMinor() + " && compactPropertyFlags.length != " + numBytes + " )" + CR); |
| sb.append(indent + tab + |
| "throw new AMQProtocolVersionException(\"Property flag array size mismatch:\" +" + CR); |
| sb.append(indent + tab + tab + "\"(Size found: \" + compactPropertyFlags.length +" + CR); |
| sb.append(indent + tab + tab + "\") Version " + version + " has " + numFields + |
| " fields which requires an int array of size " + numBytes + ".\");" + CR); |
| } |
| return sb.toString(); |
| } |
| |
| private String generateVersionCheck(AmqpVersionSet v) |
| { |
| StringBuffer sb = new StringBuffer(); |
| AmqpVersion[] versionArray = new AmqpVersion[v.size()]; |
| v.toArray(versionArray); |
| for (int i = 0; i < versionArray.length; i++) |
| { |
| if (i != 0) |
| { |
| sb.append(" || "); |
| } |
| if (versionArray.length > 1) |
| { |
| sb.append("("); |
| } |
| sb.append("major == (byte)" + versionArray[i].getMajor() + " && minor == (byte)" + |
| versionArray[i].getMinor()); |
| if (versionArray.length > 1) |
| { |
| sb.append(")"); |
| } |
| } |
| return sb.toString(); |
| } |
| |
| private String camelCaseName(String name, boolean upperFirstFlag) |
| { |
| StringBuffer ccn = new StringBuffer(); |
| String[] toks = name.split("[-_.\\ ]"); |
| for (int i = 0; i < toks.length; i++) |
| { |
| StringBuffer b = new StringBuffer(toks[i]); |
| if (upperFirstFlag || i > 0) |
| { |
| b.setCharAt(0, Character.toUpperCase(toks[i].charAt(0))); |
| } |
| ccn.append(b); |
| } |
| return ccn.toString(); |
| } |
| |
| |
| private String upperCaseName(String name) |
| { |
| StringBuffer ccn = new StringBuffer(); |
| String[] toks = name.split("[-_.\\ ]"); |
| for (int i = 0; i < toks.length; i++) |
| { |
| if (i != 0) |
| { |
| ccn.append('_'); |
| } |
| ccn.append(toks[i].toUpperCase()); |
| |
| |
| } |
| return ccn.toString(); |
| } |
| |
| |
| public static Factory<JavaGenerator> _factoryInstance = new Factory<JavaGenerator>() |
| { |
| |
| public JavaGenerator newInstance() |
| { |
| return new JavaGenerator(); |
| } |
| }; |
| |
| public static Factory<JavaGenerator> getFactory() |
| { |
| return _factoryInstance; |
| } |
| |
| |
| void processModelTemplate(NamedTemplate template, AmqpVersion version) |
| { |
| //To change body of implemented methods use File | Settings | File Templates. |
| } |
| |
| void processClassTemplate(NamedTemplate template, AmqpClass amqpClass, AmqpVersion version) |
| { |
| //To change body of implemented methods use File | Settings | File Templates. |
| } |
| |
| void processMethodTemplate(NamedTemplate template, AmqpClass amqpClass, AmqpMethod amqpMethod, AmqpVersion version) |
| { |
| //To change body of implemented methods use File | Settings | File Templates. |
| } |
| |
| void processFieldTemplate(NamedTemplate template, AmqpClass amqpClass, AmqpMethod amqpMethod, AmqpField amqpField, AmqpVersion version) |
| { |
| //To change body of implemented methods use File | Settings | File Templates. |
| } |
| |
| |
| } |
