path: root/gentools/src/org/apache/qpid/gentools/CppGenerator.java

/*
 *
 * 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.ArrayList;
import java.util.Iterator;
import java.util.TreeMap;

public class CppGenerator extends Generator
{
    protected static final String versionNamespaceStartToken = "${version_namespace_start}";
    protected static final String versionNamespaceEndToken = "${version_namespace_end}";

    // TODO: Move this to parent class
    protected static final int FIELD_NAME = 0;
    protected static final int FIELD_CODE_TYPE = 1;

    /**
     * A complete list of C++ reserved words. The names of varous XML elements within the AMQP
     * specification file are used for C++ identifier names in the generated code. Each proposed
     * name is checked against this list and is modified (by adding an '_' to the end of the
     * name - see function parseForReservedWords()) if found to be present.
     */
    protected static final String[] cppReservedWords = {"and", "and_eq", "asm", "auto", "bitand",
                                                        "bitor", "bool", "break", "case", "catch", "char", "class", "compl", "const", "const_cast",
                                                        "continue", "default", "delete", "do", "DomainInfo", "double", "dynamic_cast", "else",
                                                        "enum", "explicit", "extern", "false", "float", "for", "friend", "goto", "if", "inline",
                                                        "int", "long", "mutable", "namespace", "new", "not", "not_eq", "operator", "or", "or_eq",
                                                        "private", "protected", "public", "register", "reinterpret_cast", "return", "short",
                                                        "signed", "sizeof", "static", "static_cast", "struct", "switch", "template", "this",
                                                        "throw", "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using",
                                                        "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq"};

    /**
     * Although not reserved words, the following list of variable names that may cause compile
     * problems within a C++ environment because they clash with common #includes. The names of
     * varous XML elements within the AMQP specification file are used for C++ identifier names
     * in the generated code. Each proposed name is checked against this list and is modified
     * (by adding an '_' to the end of the name - see function parseForReservedWords()) if found
     * to be present. This list is best added to on an as-needed basis.
     */
    protected static final String[] cppCommonDefines = {"string"};

    // TODO: Move this to the Generator superclass?
    protected boolean quietFlag; // Supress warning messages to the console

    private class DomainInfo
    {
        public String type;
        public String size;
        public String encodeExpression;
        public String decodeExpression;

        public DomainInfo(String domain, String size, String encodeExpression,
                          String decodeExpression)
        {
            this.type = domain;
            this.size = size;
            this.encodeExpression = encodeExpression;
            this.decodeExpression = decodeExpression;
        }
    }

    private static TreeMap<String, DomainInfo> typeMap = new TreeMap<String, DomainInfo>();

    public CppGenerator()
    {
        super();
        quietFlag = true;
        // Load C++ 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(
                "bool",                    // type
                "~",                     // size
                "",                        // encodeExpression
                ""));                    // decodeExpression
        typeMap.put("content", new DomainInfo(
                "Content",                // type
                "#.size()",             // size
                "buffer.putContent(#)",    // encodeExpression
                "buffer.getContent(#)")); // decodeExpression
        typeMap.put("long", new DomainInfo(
                "u_int32_t",            // type
                "4",                     // size
                "buffer.putLong(#)",    // encodeExpression
                "# = buffer.getLong()"));    // decodeExpression
        typeMap.put("longlong", new DomainInfo(
                "u_int64_t",            // type
                "8",                     // size
                "buffer.putLongLong(#)", // encodeExpression
                "# = buffer.getLongLong()")); // decodeExpression
        typeMap.put("longstr", new DomainInfo(
                "string",                // type
                "4 + #.length()",         // size
                "buffer.putLongString(#)", // encodeExpression
                "buffer.getLongString(#)")); // decodeExpression
        typeMap.put("octet", new DomainInfo(
                "u_int8_t",                // type
                "1",                     // size
                "buffer.putOctet(#)",    // encodeExpression
                "# = buffer.getOctet()"));    // decodeExpression
        typeMap.put("short", new DomainInfo(
                "u_int16_t",            // type
                "2",                    // size
                "buffer.putShort(#)",    // encodeExpression
                "# = buffer.getShort()"));    // decodeExpression
        typeMap.put("shortstr", new DomainInfo(
                "string",                // type
                "1 + #.length()",        // size
                "buffer.putShortString(#)", // encodeExpression
                "buffer.getShortString(#)")); // decodeExpression
        typeMap.put("table", new DomainInfo(
                "FieldTable",            // type
                "#.size()",             // size
                "buffer.putFieldTable(#)", // encodeExpression
                "buffer.getFieldTable(#)")); // decodeExpression
        typeMap.put("timestamp", new DomainInfo(
                "u_int64_t",            // type
                "8",                     // size
                "buffer.putLongLong(#)", // encodeExpression
                "buffer.getLongLong(#)")); // decodeExpression
    }


    public boolean isQuietFlag()
    {
        return quietFlag;
    }

    public void setQuietFlag(boolean quietFlag)
    {
        this.quietFlag = quietFlag;
    }

    // === 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)
            throws AmqpTypeMappingException
    {
        String domainType = getDomainType(domainName, version);
        if (domainType == null)
        {
            throw new AmqpTypeMappingException("Domain type \"" + domainName +
                                               "\" not found in C++ typemap.");
        }
        DomainInfo info = typeMap.get(domainType);
        if (info == null)
        {
            throw new AmqpTypeMappingException("Unknown domain: \"" + domainType + "\"");
        }
        return info.type;
    }

    // === Abstract methods from class Generator - C++-specific implementation ===

    @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());
        }
        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, null);
    }

    @Override
    protected void processMethodTemplate(NamedTemplate template, AmqpClass thisClass,
                                         AmqpMethod method)
    {
        StringBuffer sb = new StringBuffer(template.getTemplate());
        String filename = prepareFilename(getTemplateFileName(sb), thisClass, method, null, null);
        boolean templateProcessedFlag = false;

        // If method is not version consistent, create a namespace for each version
        // i.e. copy the bit between the versionNamespaceStartToken and versionNamespaceEndToken
        // once for each namespace.
        if (method != null)
        {
            if (!method.isVersionConsistent(getVersionSet()))
            {
                int namespaceStartIndex = sb.indexOf(versionNamespaceStartToken);
                int namespaceEndIndex = sb.indexOf(versionNamespaceEndToken) +
                                        versionNamespaceEndToken.length();
                if (namespaceStartIndex >= 0 && namespaceEndIndex >= 0 &&
                    namespaceStartIndex <= namespaceEndIndex)
                {
                    String namespaceSpan = sb.substring(namespaceStartIndex, namespaceEndIndex) + CR;
                    sb.delete(namespaceStartIndex, namespaceEndIndex);
                    for (AmqpVersion v : method.getVersionSet())
                    {
                        StringBuffer nssb = new StringBuffer(namespaceSpan);
                        processTemplate(nssb, thisClass, method, null, template.getName(), v);
                        sb.insert(namespaceStartIndex, nssb);
                    }
                    // Process all tokens *not* within the namespace span prior to inserting namespaces
                    processTemplate(sb, thisClass, method, null, template.getName(), null);
                }
                templateProcessedFlag = true;
            }
        }
        // Remove any remaining namespace tags
        int nsTokenIndex = sb.indexOf(versionNamespaceStartToken);
        while (nsTokenIndex > 0)
        {
            sb.delete(nsTokenIndex, nsTokenIndex + versionNamespaceStartToken.length());
            nsTokenIndex = sb.indexOf(versionNamespaceStartToken);
        }
        nsTokenIndex = sb.indexOf(versionNamespaceEndToken);
        while (nsTokenIndex > 0)
        {
            sb.delete(nsTokenIndex, nsTokenIndex + versionNamespaceEndToken.length());
            nsTokenIndex = sb.indexOf(versionNamespaceEndToken);
        }

        if (!templateProcessedFlag)
        {
            processTemplate(sb, thisClass, method, null, template.getName(), null);
        }
        writeTargetFile(sb, new File(getOutputDirectory() + Utils.FILE_SEPARATOR + filename));
        generatedFileCounter++;
    }

    @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(), null);
        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("ERROR: " + templateFileName + ": " + e.getMessage());
        }
        try
        {
            processAllTokens(sb, thisClass, method, field, version);
        }
        catch (AmqpTemplateException e)
        {
            System.out.println("ERROR: " + 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)
        {
            if (version == null)
            {
                return String.valueOf(thisClass.getIndexMap().firstKey());
            }
            return getIndex(thisClass.getIndexMap(), version);
        }
        if (token.compareTo("${METHOD}") == 0 && method != null)
        {
            return method.getName();
        }
        if (token.compareTo("${METHOD_ID_INIT}") == 0 && method != null)
        {
            if (version == null)
            {
                return String.valueOf(method.getIndexMap().firstKey());
            }
            return getIndex(method.getIndexMap(), version);
        }
        if (token.compareTo("${FIELD}") == 0 && field != null)
        {
            return field.getName();
        }
        if (token.compareTo(versionNamespaceStartToken) == 0 && version != null)
        {
            return "namespace " + version.namespace() + CR + "{";
        }
        if (token.compareTo(versionNamespaceEndToken) == 0 && version != null)
        {
            return "} // namespace " + version.namespace();
        }
        if (token.compareTo("${mb_constructor_with_initializers}") == 0)
        {
            return generateConstructor(thisClass, method, version, 4, 4);
        }
        if (token.compareTo("${mb_server_operation_invoke}") == 0)
        {
            return generateServerOperationsInvoke(thisClass, method, version, 4, 4);
        }
        if (token.compareTo("${mb_buffer_param}") == 0)
        {
            return method.getFieldMap().size() > 0 ? " buffer" : "";
        }
        if (token.compareTo("${hv_latest_major}") == 0)
        {
            return String.valueOf(getVersionSet().last().getMajor());
        }
        if (token.compareTo("${hv_latest_minor}") == 0)
        {
            return String.valueOf(getVersionSet().last().getMinor());
        }

        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 tokxStart = tline.indexOf('$');
        String token = tline.substring(tokxStart).trim();
        sb.delete(listMarkerStartIndex, lend);

        // ClientOperations.h
        if (token.compareTo("${coh_method_handler_get_method}") == 0)
        {
            codeSnippet = generateOpsMethodHandlerGetMethods(model, false, 4);
        }
        else if (token.compareTo("${coh_inner_class}") == 0)
        {
            codeSnippet = generateOpsInnerClasses(model, false, 4, 4);
        }

        // ServerOperations.h
        else if (token.compareTo("${soh_method_handler_get_method}") == 0)
        {
            codeSnippet = generateOpsMethodHandlerGetMethods(model, true, 4);
        }
        else if (token.compareTo("${soh_inner_class}") == 0)
        {
            codeSnippet = generateOpsInnerClasses(model, true, 4, 4);
        }

        // ClientProxy.h/cpp
        else if (token.compareTo("${cph_inner_class_instance}") == 0)
        {
            codeSnippet = generateProxyInnerClassInstances(model, false, 4);
        }
        else if (token.compareTo("${cph_inner_class_get_method}") == 0)
        {
            codeSnippet = generateProxyInnerClassGetMethodDecls(model, false, 4);
        }
        else if (token.compareTo("${cph_inner_class_defn}") == 0)
        {
            codeSnippet = generateProxyInnerClassDefinitions(model, false, 4, 4);
        }
        else if (token.compareTo("${cpc_constructor_initializer}") == 0)
        {
            codeSnippet = generateProxyConstructorInitializers(model, false, 4);
        }
        else if (token.compareTo("${cpc_inner_class_get_method}") == 0)
        {
            codeSnippet = generateProxyInnerClassGetMethodImpls(model, false, 0, 4);
        }
        else if (token.compareTo("${cpc_inner_class_impl}") == 0)
        {
            codeSnippet = generateProxyInnerClassImpl(model, false, 0, 4);
        }
        else if (token.compareTo("${cph_handler_pointer_defn}") == 0)
        {
            codeSnippet = generateHandlerPointerDefinitions(model, false, 4);
        }
        else if (token.compareTo("${cph_handler_pointer_get_method}") == 0)
        {
            codeSnippet = generateHandlerPointerGetMethods(model, false, 4);
        }

        // SerrverProxy.h/cpp
        else if (token.compareTo("${sph_inner_class_instance}") == 0)
        {
            codeSnippet = generateProxyInnerClassInstances(model, true, 4);
        }
        else if (token.compareTo("${sph_inner_class_get_method}") == 0)
        {
            codeSnippet = generateProxyInnerClassGetMethodDecls(model, true, 4);
        }
        else if (token.compareTo("${sph_inner_class_defn}") == 0)
        {
            codeSnippet = generateProxyInnerClassDefinitions(model, true, 4, 4);
        }
        else if (token.compareTo("${spc_constructor_initializer}") == 0)
        {
            codeSnippet = generateProxyConstructorInitializers(model, true, 4);
        }
        else if (token.compareTo("${spc_inner_class_get_method}") == 0)
        {
            codeSnippet = generateProxyInnerClassGetMethodImpls(model, true, 0, 4);
        }
        else if (token.compareTo("${spc_inner_class_impl}") == 0)
        {
            codeSnippet = generateProxyInnerClassImpl(model, true, 0, 4);
        }
        else if (token.compareTo("${sph_handler_pointer_defn}") == 0)
        {
            codeSnippet = generateHandlerPointerDefinitions(model, true, 4);
        }
        else if (token.compareTo("${sph_handler_pointer_get_method}") == 0)
        {
            codeSnippet = generateHandlerPointerGetMethods(model, true, 4);
        }

        // amqp_methods.h/cpp
        else if (token.compareTo("${mh_method_body_class_indlude}") == 0)
        {
            codeSnippet = generateMethodBodyIncludeList(model, 0);
        }
        else if (token.compareTo("${mh_method_body_class_instance}") == 0)
        {
            codeSnippet = generateMethodBodyInstances(model, 0);
        }
        else if (token.compareTo("${mc_create_method_body_map_entry}") == 0)
        {
            codeSnippet = generateMethodBodyMapEntry(model, 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 tokxStart = tline.indexOf('$');
        String token = tline.substring(tokxStart).trim();
        sb.delete(listMarkerStartIndex, lend);

        if (token.compareTo("${cpc_method_body_include}") == 0)
        {
            codeSnippet = generateMethodBodyIncludes(thisClass, 0);
        }
        else if (token.compareTo("${spc_method_body_include}") == 0)
        {
            codeSnippet = generateMethodBodyIncludes(thisClass, 0);
        }
        else if (token.compareTo("${mc_method_body_include}") == 0)
        {
            codeSnippet = generateMethodBodyIncludes(thisClass, 0);
        }

        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 tokxStart = tline.indexOf('$');
        String token = tline.substring(tokxStart).trim();
        sb.delete(listMarkerStartIndex, lend);

        if (token.compareTo("${mb_field_declaration}") == 0)
        {
            codeSnippet = generateFieldDeclarations(fieldMap, version, 4);
        }
        else if (token.compareTo("${mb_field_get_method}") == 0)
        {
            codeSnippet = generateFieldGetMethods(fieldMap, version, 4);
        }
        else if (token.compareTo("${mb_field_print}") == 0)
        {
            codeSnippet = generatePrintMethodContents(fieldMap, version, 8);
        }
        else if (token.compareTo("${mb_body_size}") == 0)
        {
            codeSnippet = generateBodySizeMethodContents(fieldMap, version, 8);
        }
        else if (token.compareTo("${mb_encode}") == 0)
        {
            codeSnippet = generateEncodeMethodContents(fieldMap, version, 8);
        }
        else if (token.compareTo("${mb_decode}") == 0)
        {
            codeSnippet = generateDecodeMethodContents(fieldMap, version, 8);
        }

        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 tokxStart = tline.indexOf('$');
        String token = tline.substring(tokxStart).trim();
        sb.delete(listMarkerStartIndex, lend);

        if (token.compareTo("${ch_get_value_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 C++ implementation ===

    // Methods for generation of code snippets for AMQP_Constants.h file

    protected String generateConstantGetMethods(AmqpConstantSet constantSet,
                                                int indentSize, int tabSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        for (AmqpConstant thisConstant : constantSet.getContstants())
        {
            if (thisConstant.isVersionConsistent(getVersionSet()))
            {
                // return a constant
                String value = thisConstant.firstKey();
                sb.append(indent + "static const char* " + thisConstant.getName() + "() { return \"" +
                          thisConstant.firstKey() + "\"; }" + CR);
                if (Utils.containsOnlyDigits(value))
                {
                    sb.append(indent + "static int " + thisConstant.getName() + "AsInt() { return " +
                              thisConstant.firstKey() + "; }" + CR);
                }
                if (Utils.containsOnlyDigitsAndDecimal(value))
                {
                    sb.append(indent + "static double " + thisConstant.getName() + "AsDouble() { return (double)" +
                              thisConstant.firstKey() + "; }" + CR);
                }
                sb.append(CR);
            }
            else
            {
                // Return version-specific constant
                sb.append(generateVersionDependentGet(thisConstant, "const char*", "", "\"", "\"", indentSize, tabSize));
                sb.append(generateVersionDependentGet(thisConstant, "int", "AsInt", "", "", indentSize, tabSize));
                sb.append(generateVersionDependentGet(thisConstant, "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 + methodReturnType + " " + constant.getName() + methodNameSuffix +
                  "() const" + CR);
        sb.append(indent + "{" + CR);
        boolean first = true;
        for (String thisValue : constant.keySet())
        {
            AmqpVersionSet versionSet = constant.get(thisValue);
            sb.append(indent + tab + (first ? "" : "else ") + "if (" + generateVersionCheck(versionSet) +
                      ")" + CR);
            sb.append(indent + tab + "{" + CR);
            if (methodReturnType.compareTo("int") == 0 && !Utils.containsOnlyDigits(thisValue))
            {
                sb.append(generateConstantDeclarationException(constant.getName(), methodReturnType,
                                                               indentSize + (2 * tabSize), tabSize));
            }
            else if (methodReturnType.compareTo("double") == 0 && !Utils.containsOnlyDigitsAndDecimal(thisValue))
            {
                sb.append(generateConstantDeclarationException(constant.getName(), methodReturnType,
                                                               indentSize + (2 * tabSize), tabSize));
            }
            else
            {
                sb.append(indent + tab + tab + "return " + returnPrefix + thisValue + 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 + "std::stringstream ss;" + CR);
        sb.append(indent + tab + tab + "ss << \"Constant \\\"" + constant.getName() +
                  "\\\" is undefined for AMQP version \" <<" + CR);
        sb.append(indent + tab + tab + tab + "version.toString() << \".\";" + CR);
        sb.append(indent + tab + tab + "throw ProtocolVersionException(ss.str());" + 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 + "std::stringstream ss;" + CR);
        sb.append(indent + "ss << \"Constant \\\"" + name + "\\\" cannot be converted to type " +
                  methodReturnType + " for AMQP version \" <<" + CR);
        sb.append(indent + tab + "version.toString() << \".\";" + CR);
        sb.append(indent + "throw ProtocolVersionException(ss.str());" + CR);
        return sb.toString();
    }

    // Methods used for generation of code snippets for Server/ClientOperations class generation

    protected String generateOpsMethodHandlerGetMethods(AmqpModel model, boolean serverFlag, int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            // Only generate for this class if there is at least one method of the
            // required chassis (server/client flag).
            boolean chassisFoundFlag = false;
            for (String thisMethodName : thisClass.getMethodMap().keySet())
            {
                AmqpMethod method = thisClass.getMethodMap().get(thisMethodName);
                boolean clientChassisFlag = method.getClientMethodFlagMap().isSet();
                boolean serverChassisFlag = method.getServerMethodFlagMap().isSet();
                if ((serverFlag && serverChassisFlag) || (!serverFlag && clientChassisFlag))
                {
                    chassisFoundFlag = true;
                }
            }
            if (chassisFoundFlag)
            {
                sb.append(indent + "virtual AMQP_" + (serverFlag ? "Server" : "Client") + "Operations::" +
                          thisClass.getName() + "Handler* get" + thisClass.getName() + "Handler() = 0;" + CR);
            }
        }
        return sb.toString();
    }

    protected String generateOpsInnerClasses(AmqpModel model, boolean serverFlag, int indentSize, int tabSize)
    {

        String proxyClassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Proxy";
        String indent = Utils.createSpaces(indentSize);
        String tab = Utils.createSpaces(tabSize);
        StringBuffer sb = new StringBuffer();
        boolean first = true;
        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            String handlerClassName = thisClass.getName() + "Handler";
            if (!first)
            {
                sb.append(CR);
            }
            sb.append(indent + "// ==================== class " + handlerClassName +
                      " ====================" + CR);
            sb.append(indent + "class " + handlerClassName);
            if (thisClass.getVersionSet().size() != getVersionSet().size())
            {
                sb.append(" // AMQP Version(s) " + thisClass.getVersionSet() + CR);
            }
            else
            {
                sb.append(CR);
            }
            sb.append(indent + "{" + CR);
            sb.append(indent + "private:" + CR);
            sb.append(indent + tab + proxyClassName + "* parent;" + CR);
            sb.append(CR);
            sb.append(indent + tab + "// Constructors and destructors" + CR);
            sb.append(CR);
            sb.append(indent + "protected:" + CR);
            sb.append(indent + tab + handlerClassName + "() {}" + CR);
            sb.append(indent + "public:" + CR);
            sb.append(indent + tab + handlerClassName +
                      "(" + proxyClassName + "* _parent) {parent = _parent;}" + CR);
            sb.append(indent + tab + "virtual ~" + handlerClassName + "() {}" + CR);
            sb.append(CR);
            sb.append(indent + tab + "// Protocol methods" + CR);
            sb.append(CR);
            sb.append(generateInnerClassMethods(thisClass, serverFlag, true, indentSize + tabSize, tabSize));
            sb.append(indent + "}; // class " + handlerClassName + CR);
            first = false;
        }
        return sb.toString();
    }

    protected String generateInnerClassMethods(AmqpClass thisClass, boolean serverFlag,
                                               boolean abstractMethodFlag, int indentSize, int tabSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        String outerClassName = "AMQP_" + (serverFlag ? "Server" : "Client") + (abstractMethodFlag ? "Operations"
                                                                                : "Proxy");
        boolean first = true;
        for (String thisMethodName : thisClass.getMethodMap().keySet())
        {
            AmqpMethod method = thisClass.getMethodMap().get(thisMethodName);
            boolean clientChassisFlag = method.getClientMethodFlagMap().isSet();
            boolean serverChassisFlag = method.getServerMethodFlagMap().isSet();
            if ((serverFlag && serverChassisFlag) || (!serverFlag && clientChassisFlag))
            {
                String methodName = parseForReservedWords(method.getName(), outerClassName + "." + thisClass.getName());
                AmqpOverloadedParameterMap overloadededParameterMap =
                        method.getOverloadedParameterLists(thisClass.getVersionSet(), this);
                for (AmqpOrdinalFieldMap thisFieldMap : overloadededParameterMap.keySet())
                {
                    AmqpVersionSet versionSet = overloadededParameterMap.get(thisFieldMap);
                    if (!first)
                    {
                        sb.append(CR);
                    }
                    sb.append(indent + "virtual void " + methodName + "( u_int16_t channel");
                    sb.append(generateMethodParameterList(thisFieldMap, indentSize + (5 * tabSize), true, true, true));
                    sb.append(" )");
                    if (abstractMethodFlag)
                    {
                        sb.append(" = 0");
                    }
                    sb.append(";");
                    if (versionSet.size() != getVersionSet().size())
                    {
                        sb.append(" // AMQP Version(s) " + versionSet);
                    }
                    sb.append(CR);
                    first = false;
                }
            }
        }
        return sb.toString();
    }

    // Methods used for generation of code snippets for Server/ClientProxy class generation

    protected String generateHandlerPointerDefinitions(AmqpModel model, boolean serverFlag,
                                                       int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        String outerClassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Operations";
        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            sb.append(indent + outerClassName + "::" + thisClass.getName() + "Handler* " +
                      thisClass.getName() + "HandlerPtr;" + CR);
        }
        return sb.toString();
    }

    protected String generateHandlerPointerGetMethods(AmqpModel model, boolean serverFlag,
                                                      int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        String outerClassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Operations";
        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            sb.append(indent + "virtual inline " + outerClassName + "::" + thisClass.getName() + "Handler* get" +
                      thisClass.getName() + "Handler() { return &" + Utils.firstLower(thisClass.getName()) + ";}" + CR);
        }
        return sb.toString();
    }

    protected String generateProxyInnerClassInstances(AmqpModel model, boolean serverFlag,
                                                      int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        String outerClassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Proxy";
        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            String instanceName = parseForReservedWords(Utils.firstLower(thisClass.getName()), outerClassName);
            String className = parseForReservedWords(thisClass.getName(), null);
            sb.append(indent + className + " " + instanceName + ";");
            if (thisClass.getVersionSet().size() != getVersionSet().size())
            {
                sb.append(" // AMQP Version(s) " + thisClass.getVersionSet() + CR);
            }
            else
            {
                sb.append(CR);
            }
        }
        return sb.toString();
    }

    protected String generateProxyInnerClassGetMethodDecls(AmqpModel model, boolean serverFlag,
                                                           int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        String outerClassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Proxy";
        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            String className = parseForReservedWords(thisClass.getName(), outerClassName);
            sb.append(indent + className + "& get" + className + "();");
            if (thisClass.getVersionSet().size() != getVersionSet().size())
            {
                sb.append(" // AMQP Version(s) " + thisClass.getVersionSet() + CR);
            }
            else
            {
                sb.append(CR);
            }
        }
        return sb.toString();
    }

    protected String generateProxyInnerClassDefinitions(AmqpModel model, boolean serverFlag,
                                                        int indentSize, int tabSize)
    {
        String proxyClassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Proxy";
        String indent = Utils.createSpaces(indentSize);
        String tab = Utils.createSpaces(tabSize);
        StringBuffer sb = new StringBuffer();
        boolean first = true;
        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            String className = thisClass.getName();
            String superclassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Operations::" +
                                    thisClass.getName() + "Handler";
            if (!first)
            {
                sb.append(CR);
            }
            sb.append(indent + "// ==================== class " + className +
                      " ====================" + CR);
            sb.append(indent + "class " + className + " : virtual public " + superclassName);
            if (thisClass.getVersionSet().size() != getVersionSet().size())
            {
                sb.append(" // AMQP Version(s) " + thisClass.getVersionSet() + CR);
            }
            else
            {
                sb.append(CR);
            }
            sb.append(indent + "{" + CR);
            sb.append(indent + "private:" + CR);
            sb.append(indent + tab + "OutputHandler* out;" + CR);
            sb.append(indent + tab + proxyClassName + "* parent;" + CR);
            sb.append(CR);
            sb.append(indent + "public:" + CR);
            sb.append(indent + tab + "// Constructors and destructors" + CR);
            sb.append(CR);
            sb.append(indent + tab + className + "(OutputHandler* out, " + proxyClassName + "* _parent) : " + CR);
            sb.append(indent + tab + tab + "out(out) {parent = _parent;}" + CR);
            sb.append(indent + tab + "virtual ~" + className + "() {}" + CR);
            sb.append(CR);
            sb.append(indent + tab + "// Protocol methods" + CR);
            sb.append(CR);
            sb.append(generateInnerClassMethods(thisClass, serverFlag, false, indentSize + tabSize, tabSize));
            sb.append(indent + "}; // class " + className + CR);
            first = false;
        }
        return sb.toString();
    }

    protected String generateProxyConstructorInitializers(AmqpModel model, boolean serverFlag,
                                                          int indentSize)
    {
        String outerClassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Proxy";
        String superclassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Operations";
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer(indent + superclassName + "(major, minor)," + CR);
        sb.append(indent + "version(major, minor)," + CR);
        sb.append(indent + "out(out)");
        Iterator<String> cItr = model.getClassMap().keySet().iterator();
        while (cItr.hasNext())
        {
            AmqpClass thisClass = model.getClassMap().get(cItr.next());
            String instanceName = parseForReservedWords(Utils.firstLower(thisClass.getName()), outerClassName);
            sb.append("," + CR);
            sb.append(indent + instanceName + "(out, this)");
            if (!cItr.hasNext())
            {
                sb.append(CR);
            }
        }
        return sb.toString();
    }

    protected String generateProxyInnerClassGetMethodImpls(AmqpModel model, boolean serverFlag,
                                                           int indentSize, int tabSize)
    {
        String indent = Utils.createSpaces(indentSize);
        String tab = Utils.createSpaces(tabSize);
        StringBuffer sb = new StringBuffer();
        String outerClassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Proxy";
        Iterator<String> cItr = model.getClassMap().keySet().iterator();
        while (cItr.hasNext())
        {
            AmqpClass thisClass = model.getClassMap().get(cItr.next());
            String className = thisClass.getName();
            String instanceName = parseForReservedWords(Utils.firstLower(thisClass.getName()), outerClassName);
            sb.append(indent + outerClassName + "::" + className + "& " +
                      outerClassName + "::get" + className + "()" + CR);
            sb.append(indent + "{" + CR);
            if (thisClass.getVersionSet().size() != getVersionSet().size())
            {
                sb.append(indent + tab + "if (!" + generateVersionCheck(thisClass.getVersionSet()) + ")" + CR);
                sb.append(indent + tab + tab + "throw new ProtocolVersionException();" + CR);
            }
            sb.append(indent + tab + "return " + instanceName + ";" + CR);
            sb.append(indent + "}" + CR);
            if (cItr.hasNext())
            {
                sb.append(CR);
            }
        }
        return sb.toString();
    }

    protected String generateProxyInnerClassImpl(AmqpModel model, boolean serverFlag,
                                                 int indentSize, int tabSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        boolean firstClassFlag = true;
        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            String className = thisClass.getName();
            if (!firstClassFlag)
            {
                sb.append(CR);
            }
            sb.append(indent + "// ==================== class " + className +
                      " ====================" + CR);
            sb.append(generateInnerClassMethodImpls(thisClass, serverFlag, indentSize, tabSize));
            firstClassFlag = false;
        }
        return sb.toString();
    }

    protected String generateInnerClassMethodImpls(AmqpClass thisClass, boolean serverFlag,
                                                   int indentSize, int tabSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        String outerclassName = "AMQP_" + (serverFlag ? "Server" : "Client") + "Proxy";
        boolean first = true;
        for (String thisMethodName : thisClass.getMethodMap().keySet())
        {
            AmqpMethod method = thisClass.getMethodMap().get(thisMethodName);
            String methodBodyClassName = thisClass.getName() + Utils.firstUpper(method.getName()) + "Body";
            boolean clientChassisFlag = method.getClientMethodFlagMap().isSet();
            boolean serverChassisFlag = method.getServerMethodFlagMap().isSet();
            boolean versionConsistentFlag = method.isVersionConsistent(getVersionSet());
            if ((serverFlag && serverChassisFlag) || (!serverFlag && clientChassisFlag))
            {
                String methodName = parseForReservedWords(method.getName(), outerclassName + "." + thisClass.getName());
                AmqpOverloadedParameterMap overloadededParameterMap =
                        method.getOverloadedParameterLists(thisClass.getVersionSet(), this);
                for (AmqpOrdinalFieldMap thisFieldMap : overloadededParameterMap.keySet())
                {
                    AmqpVersionSet versionSet = overloadededParameterMap.get(thisFieldMap);
                    if (!first)
                    {
                        sb.append(CR);
                    }
                    sb.append(indent + "void " + outerclassName + "::" + thisClass.getName() + "::" +
                              methodName + "( u_int16_t channel");
                    sb.append(generateMethodParameterList(thisFieldMap, indentSize + (5 * tabSize), true, true, true));
                    sb.append(" )");
                    if (versionSet.size() != getVersionSet().size())
                    {
                        sb.append(" // AMQP Version(s) " + versionSet);
                    }
                    sb.append(CR);
                    sb.append(indent + "{" + CR);
                    sb.append(generateMethodBodyCallContext(thisFieldMap, outerclassName, methodBodyClassName,
                                                            versionConsistentFlag, versionSet, indentSize + tabSize, tabSize));
                    sb.append(indent + "}" + CR);
                    sb.append(CR);
                    first = false;
                }
            }
        }
        return sb.toString();
    }

    protected String generateMethodBodyCallContext(AmqpOrdinalFieldMap fieldMap, String outerclassName,
                                                   String methodBodyClassName, boolean versionConsistentFlag, AmqpVersionSet versionSet,
                                                   int indentSize, int tabSize)
    {
        String indent = Utils.createSpaces(indentSize);
        String tab = Utils.createSpaces(tabSize);
        StringBuffer sb = new StringBuffer();
        if (versionConsistentFlag)
        {
            sb.append(generateMethodBodyCall(fieldMap, methodBodyClassName, null, indentSize, tabSize));
        }
        else
        {
            boolean firstOverloadedMethodFlag = true;
            for (AmqpVersion thisVersion : versionSet)
            {
                sb.append(indent);
                if (!firstOverloadedMethodFlag)
                {
                    sb.append("else ");
                }
                sb.append("if (" + generateVersionCheck(thisVersion) + ")" + CR);
                sb.append(indent + "{" + CR);
                sb.append(generateMethodBodyCall(fieldMap, methodBodyClassName, thisVersion,
                                                 indentSize + tabSize, tabSize));
                sb.append(indent + "}" + CR);
                firstOverloadedMethodFlag = false;
            }
            sb.append(indent + "else" + CR);
            sb.append(indent + "{" + CR);
            sb.append(indent + tab + "std::stringstream ss;" + CR);
            sb.append(indent + tab + "ss << \"Call to " + outerclassName + "::" + methodBodyClassName +
                      "(u_int16_t" + generateMethodParameterList(fieldMap, 0, true, true, false) + ")\"" + CR);
            sb.append(indent + tab + tab + "<< \" is invalid for AMQP version \" << version.toString() << \".\";" + CR);
            sb.append(indent + tab + "throw new ProtocolVersionException(ss.str());" + CR);
            sb.append(indent + "}" + CR);
        }
        return sb.toString();
    }

    protected String generateMethodBodyCall(AmqpOrdinalFieldMap fieldMap, String methodBodyClassName,
                                            AmqpVersion version, int indentSize, int tabSize)
    {
        String indent = Utils.createSpaces(indentSize);
        String tab = Utils.createSpaces(tabSize);
        String namespace = version != null ? version.namespace() + "::" : "";
        StringBuffer sb = new StringBuffer(indent + "out->send( new AMQFrame(parent->getProtocolVersion(), channel," + CR);
        sb.append(indent + tab + "new " + namespace + methodBodyClassName + "( parent->getProtocolVersion()");
        sb.append(generateMethodParameterList(fieldMap, indentSize + (5 * tabSize), true, false, true));
        sb.append(" )));" + CR);
        return sb.toString();
    }

    protected String generateMethodBodyIncludes(AmqpClass thisClass, int indentSize)
    {
        StringBuffer sb = new StringBuffer();
        if (thisClass != null)
        {
            sb.append(generateClassMethodBodyInclude(thisClass, indentSize));
        }
        else
        {
            for (String thisClassName : getModel().getClassMap().keySet())
            {
                thisClass = getModel().getClassMap().get(thisClassName);
                sb.append(generateClassMethodBodyInclude(thisClass, indentSize));
            }
        }
        return sb.toString();
    }

    protected String generateClassMethodBodyInclude(AmqpClass thisClass, int indentSize)
    {
        StringBuffer sb = new StringBuffer();
        String indent = Utils.createSpaces(indentSize);
        for (String thisMethodName : thisClass.getMethodMap().keySet())
        {
            AmqpMethod method = thisClass.getMethodMap().get(thisMethodName);
            sb.append(indent + "#include <" + thisClass.getName() +
                      Utils.firstUpper(method.getName()) + "Body.h>" + CR);
        }
        return sb.toString();
    }

    // Methods used for generation of code snippets for MethodBody class generation

    protected String getIndex(AmqpOrdinalVersionMap indexMap, AmqpVersion version)
    {
        for (Integer thisIndex : indexMap.keySet())
        {
            AmqpVersionSet versionSet = indexMap.get(thisIndex);
            if (versionSet.contains(version))
            {
                return String.valueOf(thisIndex);
            }
        }
        throw new AmqpTemplateException("Unable to find index for version " + version);
    }

    protected String generateFieldDeclarations(AmqpFieldMap fieldMap, AmqpVersion version, int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();

        if (version == null)
        {
            version = getVersionSet().first();
        }
        AmqpOrdinalFieldMap ordinalFieldMap = fieldMap.getMapForVersion(version, true, this);
        for (Integer thisOrdinal : ordinalFieldMap.keySet())
        {
            String[] fieldDomainPair = ordinalFieldMap.get(thisOrdinal);
            sb.append(indent + fieldDomainPair[FIELD_CODE_TYPE] + " " + fieldDomainPair[FIELD_NAME] + ";" + CR);
        }
        return sb.toString();
    }

    protected String generateFieldGetMethods(AmqpFieldMap fieldMap, AmqpVersion version, int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();

        if (version == null)
        {
            version = getVersionSet().first();
        }
        AmqpOrdinalFieldMap ordinalFieldMap = fieldMap.getMapForVersion(version, true, this);
        for (Integer thisOrdinal : ordinalFieldMap.keySet())
        {
            String[] fieldDomainPair = ordinalFieldMap.get(thisOrdinal);
            sb.append(indent + "inline " + setRef(fieldDomainPair[FIELD_CODE_TYPE]) + " get" +
                      Utils.firstUpper(fieldDomainPair[FIELD_NAME]) + "() { return " +
                      fieldDomainPair[FIELD_NAME] + "; }" + CR);
        }
        return sb.toString();
    }

    protected String generatePrintMethodContents(AmqpFieldMap fieldMap, AmqpVersion version, int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();

        if (version == null)
        {
            version = getVersionSet().first();
        }
        AmqpOrdinalFieldMap ordinalFieldMap = fieldMap.getMapForVersion(version, true, this);
        boolean firstFlag = true;
        for (Integer thisOrdinal : ordinalFieldMap.keySet())
        {
            String[] fieldDomainPair = ordinalFieldMap.get(thisOrdinal);
            String cast = fieldDomainPair[FIELD_CODE_TYPE].compareTo("u_int8_t") == 0 ? "(int)" : "";
            sb.append(indent + "out << \"");
            if (!firstFlag)
            {
                sb.append("; ");
            }
            sb.append(fieldDomainPair[FIELD_NAME] + "=\" << " + cast + fieldDomainPair[FIELD_NAME] + ";" + CR);
            firstFlag = false;
        }
        return sb.toString();
    }

    protected String generateBodySizeMethodContents(AmqpFieldMap fieldMap, AmqpVersion version,
                                                    int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        ArrayList<String> bitFieldList = new ArrayList<String>();
        AmqpOrdinalFieldMap ordinalFieldMap = fieldMap.getMapForVersion(version, false, this);
        Iterator<Integer> oItr = ordinalFieldMap.keySet().iterator();
        int ordinal = 0;
        while (oItr.hasNext())
        {
            ordinal = oItr.next();
            String[] fieldDomainPair = ordinalFieldMap.get(ordinal);
            AmqpVersion thisVersion = version == null ? getVersionSet().first() : version;
            String domainType = getDomainType(fieldDomainPair[FIELD_CODE_TYPE], thisVersion);

            // Defer bit types by adding them to an array. When the first subsequent non-bit
            // type is encountered, then handle the bits. This allows consecutive bits to be
            // placed into the same byte(s) - 8 bits to the byte.
            if (domainType.compareTo("bit") == 0)
            {
                bitFieldList.add(fieldDomainPair[FIELD_NAME]);
            }
            else
            {
                if (bitFieldList.size() > 0) // Handle accumulated bit types (if any)
                {
                    sb.append(generateBitArrayBodySizeMethodContents(bitFieldList, ordinal, indentSize));
                }
                sb.append(indent + "size += " +
                          typeMap.get(domainType).size.replaceAll("#", fieldDomainPair[FIELD_NAME]) +
                          "; /* " + fieldDomainPair[FIELD_NAME] + ": " +
                          domainType + " */" + CR);
            }
        }
        if (bitFieldList.size() > 0) // Handle any remaining accumulated bit types
        {
            sb.append(generateBitArrayBodySizeMethodContents(bitFieldList, ordinal, indentSize));
        }
        return sb.toString();
    }

    protected String generateBitArrayBodySizeMethodContents(ArrayList<String> bitFieldList,
                                                            int ordinal, int indentSize)
    {
        int numBytes = ((bitFieldList.size() - 1) / 8) + 1;
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        String comment = bitFieldList.size() == 1 ?
                         bitFieldList.get(0) + ": bit" :
                         "Combinded bits: " + bitFieldList;
        sb.append(indent + "size += " +
                  typeMap.get("bit").size.replaceAll("~", String.valueOf(numBytes)) +
                  "; /* " + comment + " */" + CR);
        bitFieldList.clear();
        return sb.toString();
    }

    protected String generateEncodeMethodContents(AmqpFieldMap fieldMap, AmqpVersion version,
                                                  int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        ArrayList<String> bitFieldList = new ArrayList<String>();
        AmqpOrdinalFieldMap ordinalFieldMap = fieldMap.getMapForVersion(version, false, this);
        Iterator<Integer> oItr = ordinalFieldMap.keySet().iterator();
        int ordinal = 0;
        while (oItr.hasNext())
        {
            ordinal = oItr.next();
            String[] fieldDomainPair = ordinalFieldMap.get(ordinal);
            AmqpVersion thisVersion = version == null ? getVersionSet().first() : version;
            String domainType = getDomainType(fieldDomainPair[FIELD_CODE_TYPE], thisVersion);

            // Defer bit types by adding them to an array. When the first subsequent non-bit
            // type is encountered, then handle the bits. This allows consecutive bits to be
            // placed into the same byte(s) - 8 bits to the byte.
            if (domainType.compareTo("bit") == 0)
            {
                bitFieldList.add(fieldDomainPair[FIELD_NAME]);
            }
            else
            {
                if (bitFieldList.size() > 0) // Handle accumulated bit types (if any)
                {
                    sb.append(generateBitEncodeMethodContents(bitFieldList, ordinal, indentSize));
                }
                sb.append(indent +
                          typeMap.get(domainType).encodeExpression.replaceAll("#", fieldDomainPair[FIELD_NAME]) +
                          "; /* " + fieldDomainPair[FIELD_NAME] + ": " + domainType + " */" + CR);
            }
        }
        if (bitFieldList.size() > 0) // Handle any remaining accumulated bit types
        {
            sb.append(generateBitEncodeMethodContents(bitFieldList, ordinal, indentSize));
        }

        return sb.toString();
    }

    protected String generateBitEncodeMethodContents(ArrayList<String> bitFieldList, int ordinal,
                                                     int indentSize)
    {
        int numBytes = ((bitFieldList.size() - 1) / 8) + 1;
        String indent = Utils.createSpaces(indentSize);
        String bitArrayName = "flags_" + ordinal;
        StringBuffer sb = new StringBuffer(indent + "u_int8_t " + bitArrayName +
                                           "[" + numBytes + "] = {0};" +
                                           (numBytes != 1 ? " /* All array elements will be initialized to 0 */" : "") +
                                           CR);
        for (int i = 0; i < bitFieldList.size(); i++)
        {
            int bitIndex = i % 8;
            int byteIndex = i / 8;
            sb.append(indent + bitArrayName + "[" + byteIndex + "] |= " + bitFieldList.get(i) +
                      " << " + bitIndex + "; /* " + bitFieldList.get(i) + ": bit */" + CR);
        }
        for (int i = 0; i < numBytes; i++)
        {
            sb.append(indent + "buffer.putOctet(" + bitArrayName + "[" + i + "]);" + CR);
        }
        bitFieldList.clear();
        return sb.toString();
    }

    protected String generateDecodeMethodContents(AmqpFieldMap fieldMap, AmqpVersion version,
                                                  int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        ArrayList<String> bitFieldList = new ArrayList<String>();
        AmqpOrdinalFieldMap ordinalFieldMap = fieldMap.getMapForVersion(version, false, this);
        Iterator<Integer> oItr = ordinalFieldMap.keySet().iterator();
        int ordinal = 0;
        while (oItr.hasNext())
        {
            ordinal = oItr.next();
            String[] fieldDomainPair = ordinalFieldMap.get(ordinal);
            AmqpVersion thisVersion = version == null ? getVersionSet().first() : version;
            String domainType = getDomainType(fieldDomainPair[FIELD_CODE_TYPE], thisVersion);

            // Defer bit types by adding them to an array. When the first subsequent non-bit
            // type is encountered, then handle the bits. This allows consecutive bits to be
            // placed into the same byte(s) - 8 bits to the byte.
            if (domainType.compareTo("bit") == 0)
            {
                bitFieldList.add(fieldDomainPair[FIELD_NAME]);
            }
            else
            {
                if (bitFieldList.size() > 0) // Handle accumulated bit types (if any)
                {
                    sb.append(generateBitDecodeMethodContents(bitFieldList, ordinal, indentSize));
                }
                sb.append(indent +
                          typeMap.get(domainType).decodeExpression.replaceAll("#", fieldDomainPair[FIELD_NAME]) +
                          "; /* " + fieldDomainPair[FIELD_NAME] + ": " + domainType + " */" + CR);
            }
        }
        if (bitFieldList.size() > 0) // Handle any remaining accumulated bit types
        {
            sb.append(generateBitDecodeMethodContents(bitFieldList, ordinal, indentSize));
        }

        return sb.toString();
    }

    protected String generateBitDecodeMethodContents(ArrayList<String> bitFieldList, int ordinal,
                                                     int indentSize)
    {
        int numBytes = ((bitFieldList.size() - 1) / 8) + 1;
        String indent = Utils.createSpaces(indentSize);
        String bitArrayName = "flags_" + ordinal;
        StringBuffer sb = new StringBuffer(indent + "u_int8_t " + bitArrayName +
                                           "[" + numBytes + "];" + CR);
        for (int i = 0; i < numBytes; i++)
        {
            sb.append(indent + bitArrayName + "[" + i + "] = buffer.getOctet();" + CR);
        }
        for (int i = 0; i < bitFieldList.size(); i++)
        {
            int bitIndex = i % 8;
            int byteIndex = i / 8;
            sb.append(indent + bitFieldList.get(i) + " = (1 << " + bitIndex + ") & " +
                      bitArrayName + "[" + byteIndex + "]; /* " + bitFieldList.get(i) +
                      ": bit */" + CR);
        }
        bitFieldList.clear();
        return sb.toString();
    }

    protected String generateFieldList(AmqpFieldMap fieldMap, AmqpVersion version, boolean defineFlag,
                                       boolean initializerFlag, int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        AmqpOrdinalFieldMap ordinalFieldMap = fieldMap.getMapForVersion(version, true, this);
        Iterator<Integer> oItr = ordinalFieldMap.keySet().iterator();
        while (oItr.hasNext())
        {
            int ordinal = oItr.next();
            String[] fieldDomainPair = ordinalFieldMap.get(ordinal);
            sb.append(indent + (defineFlag ? setRef(fieldDomainPair[FIELD_CODE_TYPE]) + " " : "") +
                      fieldDomainPair[FIELD_NAME] + (initializerFlag ? "(" + fieldDomainPair[FIELD_NAME] + ")" : "") +
                      (oItr.hasNext() ? "," : "") + CR);
        }
        return sb.toString();
    }

    protected String generateMethodParameterList(AmqpOrdinalFieldMap fieldMap, int indentSize,
                                                 boolean leadingCommaFlag, boolean fieldTypeFlag, boolean fieldNameFlag)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();
        boolean first = true;
        Iterator<Integer> pItr = fieldMap.keySet().iterator();
        while (pItr.hasNext())
        {
            String[] field = fieldMap.get(pItr.next());
            if (first && leadingCommaFlag)
            {
                sb.append("," + (fieldNameFlag ? CR : " "));
            }
            if (!first || leadingCommaFlag)
            {
                sb.append(indent);
            }
            sb.append(
                    (fieldTypeFlag ? setRef(field[FIELD_CODE_TYPE]) : "") +
                    (fieldNameFlag ? " " + field[FIELD_NAME] : "") +
                    (pItr.hasNext() ? "," + (fieldNameFlag ? CR : " ") : ""));
            first = false;
        }
        return sb.toString();
    }

    protected String generateConstructor(AmqpClass thisClass, AmqpMethod method,
                                         AmqpVersion version, int indentSize, int tabSize)
    {
        String indent = Utils.createSpaces(indentSize);
        String tab = Utils.createSpaces(tabSize);
        StringBuffer sb = new StringBuffer();
        if (method.getFieldMap().size() > 0)
        {
            sb.append(indent + thisClass.getName() + Utils.firstUpper(method.getName()) + "Body(ProtocolVersion& version," + CR);
            sb.append(generateFieldList(method.getFieldMap(), version, true, false, 8));
            sb.append(indent + tab + ") :" + CR);
            sb.append(indent + tab + "AMQMethodBody(version)," + CR);
            sb.append(generateFieldList(method.getFieldMap(), version, false, true, 8));
            sb.append(indent + "{ }" + CR);
        }
        return sb.toString();
    }

    protected String generateServerOperationsInvoke(AmqpClass thisClass, AmqpMethod method,
                                                    AmqpVersion version, int indentSize, int tabSize)
    {
        String indent = Utils.createSpaces(indentSize);
        String tab = Utils.createSpaces(tabSize);
        StringBuffer sb = new StringBuffer();

        if (method.getServerMethodFlagMap().size() > 0) // At least one AMQP version defines this method as a server method
        {
            Iterator<Boolean> bItr = method.getServerMethodFlagMap().keySet().iterator();
            while (bItr.hasNext())
            {
                if (bItr.next()) // This is a server operation
                {
                    boolean fieldMapNotEmptyFlag = method.getFieldMap().size() > 0;
                    sb.append(indent + "inline void invoke(AMQP_ServerOperations& target, u_int16_t channel)" + CR);
                    sb.append(indent + "{" + CR);
                    sb.append(indent + tab + "target.get" + thisClass.getName() + "Handler()->" +
                              parseForReservedWords(Utils.firstLower(method.getName()),
                                                    thisClass.getName() + Utils.firstUpper(method.getName()) + "Body.invoke()") + "(channel");
                    if (fieldMapNotEmptyFlag)
                    {
                        sb.append("," + CR);
                        sb.append(generateFieldList(method.getFieldMap(), version, false, false, indentSize + 4 * tabSize));
                        sb.append(indent + tab + tab + tab + tab);
                    }
                    sb.append(");" + CR);
                    sb.append(indent + "}" + CR);
                }
            }
        }
        return sb.toString();
    }

    // Methods for generation of code snippets for amqp_methods.h/cpp files

    protected String generateMethodBodyIncludeList(AmqpModel model, int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();

        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            for (String thisMethodName : thisClass.getMethodMap().keySet())
            {
                AmqpMethod method = thisClass.getMethodMap().get(thisMethodName);
                sb.append(indent + "#include \"" + thisClass.getName() + Utils.firstUpper(method.getName()) + "Body.h\"" + CR);
            }
        }

        return sb.toString();
    }

    protected String generateMethodBodyInstances(AmqpModel model, int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();

        for (String thisClassName : model.getClassMap().keySet())
        {
            AmqpClass thisClass = model.getClassMap().get(thisClassName);
            for (String thisMethodName : thisClass.getMethodMap().keySet())
            {
                AmqpMethod method = thisClass.getMethodMap().get(thisMethodName);
                sb.append(indent + "const " + thisClass.getName() + Utils.firstUpper(method.getName()) + "Body " +
                          Utils.firstLower(thisClass.getName()) + "_" + method.getName() + ";" + CR);
            }
        }

        return sb.toString();
    }

    protected String generateMethodBodyMapEntry(AmqpModel model, int indentSize)
    {
        String indent = Utils.createSpaces(indentSize);
        StringBuffer sb = new StringBuffer();

        for (AmqpVersion version : getVersionSet())
        {
            for (String thisClassName : model.getClassMap().keySet())
            {
                AmqpClass thisClass = model.getClassMap().get(thisClassName);
                for (String thisMethodName : thisClass.getMethodMap().keySet())
                {
                    AmqpMethod method = thisClass.getMethodMap().get(thisMethodName);
                    String namespace = method.isVersionConsistent(getVersionSet()) ? "" : version.namespace() + "::";
                    try
                    {
                        int classOrdinal = thisClass.getIndexMap().getOrdinal(version);
                        int methodOrdinal = method.getIndexMap().getOrdinal(version);
                        String methodModyClassName = namespace + thisClass.getName() + Utils.firstUpper(method.getName()) + "Body";
                        sb.append(indent + "insert(std::make_pair(createMapKey(" + classOrdinal + ", " +
                                  methodOrdinal + ", " + version.getMajor() + ", " + version.getMinor() +
                                  "), &createMethodBodyFn<" + methodModyClassName + ">));" + CR);
                    }
                    catch (AmqpTypeMappingException e)
                    {
                    } // ignore
                }
            }
        }

        return sb.toString();
    }

    // Helper functions

    private String generateVersionCheck(AmqpVersion version)
    {
        return "version.equals(" + version.getMajor() + ", " + version.getMinor() + ")";
    }

    private String generateVersionCheck(AmqpVersionSet versionSet)
    {
        StringBuffer sb = new StringBuffer();
        for (AmqpVersion v : versionSet)
        {
            if (!v.equals(versionSet.first()))
            {
                sb.append(" || ");
            }
            if (versionSet.size() > 1)
            {
                sb.append("(");
            }
            sb.append("version.equals(" + v.getMajor() + ", " + v.getMinor() + ")");
            if (versionSet.size() > 1)
            {
                sb.append(")");
            }
        }
        return sb.toString();
    }

    private String parseForReservedWords(String name, String context)
    {
        for (String cppReservedWord : cppReservedWords)
        {
            if (name.compareTo(cppReservedWord) == 0)
            {
                if (!quietFlag)
                {
                    System.out.println("WARNING: " + (context == null ? "" : context + ": ") +
                                       "Found XML method \"" + name + "\", which is a C++ reserved word. " +
                                       "Changing generated name to \"" + name + "_\".");
                }
                return name + "_";
            }
        }

        for (String cppCommonDefine : cppCommonDefines)
        {
            if (name.compareTo(cppCommonDefine) == 0)
            {
                if (!quietFlag)
                {
                    System.out.println("WARNING: " + (context == null ? "" : context + ": ") +
                                       "Found XML method \"" + name + "\", which may clash with commonly used defines within C++. " +
                                       "Changing generated name to \"" + name + "_\".");
                }
                return name + "_";
            }
        }

        return name;
    }

    private String setRef(String codeType)
    {
        if (codeType.compareTo("string") == 0 ||
            codeType.compareTo("FieldTable") == 0)
        {
            return "const " + codeType + "&";
        }
        return codeType;
    }

    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();
    }

    public static Factory<CppGenerator> _factoryInstance = new Factory<CppGenerator>()
    {

        public CppGenerator newInstance()
        {
            return new CppGenerator();
        }
    };

    public static Factory<CppGenerator> getFactory()
    {
        return _factoryInstance;
    }

    void processModelTemplate(NamedTemplate template, AmqpVersion version)
    {
        //To change body of implemented methods use File | Settings | File Templates.
    }
    public String getNativeType(String type)
    {
        throw new UnsupportedOperationException();
    }

    public String getEncodingType(String type)
    {
        throw new UnsupportedOperationException();
    }

}