Renamed cpp-0-9 to cpp

git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk@520706 13f79535-47bb-0310-9956-ffa450edef68

32 files changed, 6880 insertions, 0 deletions

diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpClass.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpClass.java
new file mode 100644
index 0000000000..2e8bdaf971
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpClass.java
@@ -0,0 +1,148 @@
+/*
+ *
+ * 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.PrintStream;
+
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+public class AmqpClass implements Printable, NodeAware 
+{
+	public LanguageConverter converter;
+	public AmqpVersionSet versionSet;
+	public AmqpFieldMap fieldMap;
+	public AmqpMethodMap methodMap;
+	public String name;
+	public AmqpOrdinalVersionMap indexMap;
+	
+	public AmqpClass(String name, LanguageConverter converter)
+	{
+		this.name = name;
+		this.converter = converter;
+		versionSet = new AmqpVersionSet();
+		fieldMap = new AmqpFieldMap();
+		methodMap = new AmqpMethodMap();
+		indexMap = new AmqpOrdinalVersionMap();
+	}
+
+	public boolean addFromNode(Node classNode, int ordinal, AmqpVersion version)
+		throws AmqpParseException, AmqpTypeMappingException
+	{
+		versionSet.add(version);
+		int index = Utils.getNamedIntegerAttribute(classNode, "index");
+		AmqpVersionSet indexVersionSet = indexMap.get(index);
+		if (indexVersionSet != null)
+			indexVersionSet.add(version);
+		else
+		{
+			indexVersionSet = new AmqpVersionSet();
+			indexVersionSet.add(version);
+			indexMap.put(index, indexVersionSet);
+		}
+		NodeList nList = classNode.getChildNodes();
+		int fieldCntr = fieldMap.size();
+		for (int i=0; i<nList.getLength(); i++)
+		{
+			Node child = nList.item(i);
+			if (child.getNodeName().compareTo(Utils.ELEMENT_FIELD) == 0)
+			{
+				String fieldName = converter.prepareDomainName(Utils.getNamedAttribute(child,
+						Utils.ATTRIBUTE_NAME));
+				AmqpField thisField = fieldMap.get(fieldName);
+				if (thisField == null)
+				{
+					thisField = new AmqpField(fieldName, converter);
+					fieldMap.put(fieldName, thisField);
+				}
+				if (!thisField.addFromNode(child, fieldCntr++, version))
+				{
+					String className = converter.prepareClassName(Utils.getNamedAttribute(classNode,
+							Utils.ATTRIBUTE_NAME));
+					System.out.println("INFO: Generation supression tag found for field " +
+							className + "." + fieldName + " - removing.");
+					thisField.removeVersion(version);
+					fieldMap.remove(fieldName);
+				}
+			}
+			else if (child.getNodeName().compareTo(Utils.ELEMENT_METHOD) == 0)
+			{
+				String methodName = converter.prepareMethodName(Utils.getNamedAttribute(child,
+						Utils.ATTRIBUTE_NAME));
+				AmqpMethod thisMethod = methodMap.get(methodName);
+				if (thisMethod == null)
+				{
+					thisMethod = new AmqpMethod(methodName, converter);
+					methodMap.put(methodName, thisMethod);
+				}			
+				if (!thisMethod.addFromNode(child, 0, version))
+				{
+					String className = converter.prepareClassName(Utils.getNamedAttribute(classNode,
+							Utils.ATTRIBUTE_NAME));
+					System.out.println("INFO: Generation supression tag found for method " +
+							className + "." + methodName + " - removing.");
+					thisMethod.removeVersion(version);
+					methodMap.remove(methodName);
+				}
+			}
+			else if (child.getNodeName().compareTo(Utils.ELEMENT_CODEGEN) == 0)
+			{
+				String value = Utils.getNamedAttribute(child, Utils.ATTRIBUTE_VALUE);
+				if (value.compareTo("no-gen") == 0)
+					return false;
+			}
+		}
+		return true;
+	}
+	
+	public void removeVersion(AmqpVersion version)
+	{
+		indexMap.removeVersion(version);
+		fieldMap.removeVersion(version);
+		methodMap.removeVersion(version);
+		versionSet.remove(version);
+	}
+	
+	public void print(PrintStream out, int marginSize, int tabSize)
+	{
+		String margin = Utils.createSpaces(marginSize);
+		String tab = Utils.createSpaces(tabSize);
+		out.println(margin + "[C] " + name + ": " + versionSet);
+		
+		for (Integer thisIndex : indexMap.keySet())
+		{
+			AmqpVersionSet indexVersionSet = indexMap.get(thisIndex);
+			out.println(margin + tab + "[I] " + thisIndex + indexVersionSet);
+		}
+		
+		for (String thisFieldName : fieldMap.keySet())
+		{
+			AmqpField thisField = fieldMap.get(thisFieldName);
+			thisField.print(out, marginSize + tabSize, tabSize);
+		}
+		
+		for (String thisMethodName : methodMap.keySet())
+		{
+			AmqpMethod thisMethod = methodMap.get(thisMethodName);
+			thisMethod.print(out, marginSize + tabSize, tabSize);
+		}
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpClassMap.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpClassMap.java
new file mode 100644
index 0000000000..01d4df283b
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpClassMap.java
@@ -0,0 +1,29 @@
+/*
+ *
+ * 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.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class AmqpClassMap extends TreeMap<String, AmqpClass>
+{
+	
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpConstant.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpConstant.java
new file mode 100644
index 0000000000..6ccd2dbf99
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpConstant.java
@@ -0,0 +1,205 @@
+/*
+ *
+ * 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.PrintStream;
+import java.util.TreeMap;
+
+/**
+ * @author kpvdr
+ * Class to represent the &lt;constant&gt; declaration within the AMQP specification.
+ * Currently, only integer values exist within the specification, however looking forward
+ * to other possible types in the future, string and double types are also supported.
+ * 
+ * The &lt;constant&gt; declaration in the specification contains only two attributes:
+ * name and value.
+ * 
+ * The value of the constant is mapped against the version(s) for which the name is defined.
+ * This allows for a change in the value rather than the name only from one version to the next.
+ */
+@SuppressWarnings("serial")
+public class AmqpConstant extends TreeMap<String, AmqpVersionSet>
+    implements Printable, VersionConsistencyCheck, Comparable<AmqpConstant>
+{
+    /**
+     * Constant name as defined by the name attribute of the &lt;constant&gt; declaration.
+     */
+    protected String name;
+    
+    /**
+     * Set of versions for which this constant name is defined.
+     */
+    protected AmqpVersionSet versionSet;
+
+    /**
+     * Constructor
+     * @param name Constant name as defined by the name attribute of the &lt;constant&gt; declaration.
+     * @param value Constant value as defined by the value attribute of the &lt;constant&gt; declaration.
+     * @param version AMQP version for which this constant is defined
+     */
+    public AmqpConstant (String name, String value, AmqpVersion version)
+    {
+        this.name = name;
+        versionSet = new AmqpVersionSet(version);
+        AmqpVersionSet valueVersionSet = new  AmqpVersionSet(version);
+        put(value, valueVersionSet);
+     }
+
+    /**
+     * Constructor
+     * @param name Constant name as defined by the name attribute of the &lt;constant&gt; declaration.
+     * @param value Constant value as defined by the value attribute of the &lt;constant&gt; declaration.
+     * @param version AMQP version for which this constant is defined
+     */
+    public AmqpConstant (String name, int value, AmqpVersion version)
+    {
+        this.name = name;
+        versionSet = new AmqpVersionSet(version);
+        AmqpVersionSet valueVersionSet = new  AmqpVersionSet(version);
+        put(String.valueOf(value), valueVersionSet);
+    }
+
+    /**
+     * Constructor
+     * @param name Constant name as defined by the name attribute of the &lt;constant&gt; declaration.
+     * @param value Constant value as defined by the value attribute of the &lt;constant&gt; declaration.
+     * @param version AMQP version for which this constant is defined
+     */
+    public AmqpConstant (String name, double value, AmqpVersion version)
+    {
+        this.name = name;
+        versionSet = new AmqpVersionSet(version);
+        AmqpVersionSet valueVersionSet = new  AmqpVersionSet(version);
+        put(String.valueOf(value), valueVersionSet);
+    }
+
+    /**
+     * Get the name of this constant.
+     * @return Name of this constant, being the name attribute of the &lt;constant&gt; declaration
+     * represented by this class.
+     */
+    public String getName()
+    {
+        return name;
+    }
+    
+    /**
+     * Get the value of this constant as a String.
+     * @param version AMQP version for which this value is required.
+     * @return Value of this constant, being the value attribute of the &lt;constant&gt; declaration
+     * represented by this class.
+     * @throws AmqpTypeMappingException when a value is requested for a version for which it is not
+     * defined in the AMQP specifications.
+     */
+    public String getStringValue(AmqpVersion version)
+    throws AmqpTypeMappingException
+    {
+    	for (String thisValue : keySet())
+        {
+            AmqpVersionSet versionSet = get(thisValue);
+            if (versionSet.contains(version))
+                return thisValue;
+        }
+        throw new AmqpTypeMappingException("Unable to find value for constant \"" + name +
+            "\" for version " + version.toString() + ".");
+    }
+    
+    /**
+     * Get the value of this constant as an integer.
+     * @param version AMQP version for which this value is required.
+     * @return Value of this constant, being the value attribute of the &lt;constant&gt; declaration
+     * represented by this class.
+     * @throws AmqpTypeMappingException when a value is requested for a version for which it is not
+     * defined in the AMQP specifications.
+     */
+    public int getIntegerValue(AmqpVersion version)
+    throws AmqpTypeMappingException
+    {
+        return Integer.parseInt(getStringValue(version));
+    }
+    
+    /**
+     * Get the value of this constant as a double.
+     * @param version AMQP version for which this value is required.
+     * @return Value of this constant, being the value attribute of the &lt;constant&gt; declaration
+     * represented by this class.
+     * @throws AmqpTypeMappingException when a value is requested for a version for which it is not
+     * defined in the AMQP specifications.
+     */
+    public double getDoubleValue(AmqpVersion version)
+    throws AmqpTypeMappingException
+    {
+        return Double.parseDouble(getStringValue(version));
+    }
+    
+    /**
+     * Get the version set for this constant. It contains the all the versions for which this
+     * constant name exists.
+     * @return Set of versions for which this constant exists.
+     */
+    public AmqpVersionSet getVersionSet()
+    {
+        return versionSet;
+    }
+    
+    /* (non-Javadoc)
+     * @see java.lang.Comparable#compareTo(java.lang.Object)
+     */
+    
+    public int compareTo(AmqpConstant other)
+    {
+        int res = name.compareTo(other.name);
+        if (res != 0)
+            return res;
+        return versionSet.compareTo(other.versionSet);
+    }
+
+    /* (non-Javadoc)
+     * @see org.apache.qpid.gentools.VersionConsistencyCheck#isVersionConsistent(org.apache.qpid.gentools.AmqpVersionSet)
+     */
+    public boolean isVersionConsistent(AmqpVersionSet globalVersionSet)
+    {
+        if (size() != 1)
+            return false;
+        return get(firstKey()).equals(globalVersionSet);
+    }
+
+    /* (non-Javadoc)
+     * @see org.apache.qpid.gentools.Printable#print(java.io.PrintStream, int, int)
+     */
+    public void print(PrintStream out, int marginSize, int tabSize)
+    {
+        String margin = Utils.createSpaces(marginSize);
+        String tab = Utils.createSpaces(tabSize);
+        if (size() == 1)
+        {
+            out.println(margin + tab + "[C] " + name + " = \"" + firstKey() + "\" " + versionSet);
+        }
+        else
+        {
+            out.println(margin + tab + "[C] " + name + ": " + versionSet);
+            for (String thisValue : keySet())
+            {
+                 out.println(margin + tab + tab + "= \"" + thisValue + "\" " + get(thisValue));
+            }
+        }
+    }
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpConstantSet.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpConstantSet.java
new file mode 100644
index 0000000000..7b38f5cf3c
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpConstantSet.java
@@ -0,0 +1,133 @@
+/*
+ *
+ * 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.PrintStream;
+import java.util.Iterator;
+import java.util.TreeSet;
+
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * @author kpvdr
+ * This class implements a set collection for {@link #AmqpConstant AmqpConstant} objects, being the collection
+ * of constants accumulated from various AMQP specification files processed. Each name occurs once only in the set.
+ * The {@link #AmqpConstant AmqpConstant} objects (derived from {@link java.util#TreeMap TreeMap}) keep track of
+ * the value and version(s) assigned to this name.
+ */
+@SuppressWarnings("serial")
+public class AmqpConstantSet extends TreeSet<AmqpConstant> implements Printable, NodeAware, Comparable<AmqpConstantSet>
+{
+    public LanguageConverter converter;
+
+    public AmqpConstantSet(LanguageConverter converter)
+    {
+        this.converter = converter;
+        this.converter.setConstantSet(this);
+    }
+    
+   /* (non-Javadoc)
+     * @see org.apache.qpid.gentools.NodeAware#addFromNode(org.w3c.dom.Node, int, org.apache.qpid.gentools.AmqpVersion)
+     */
+    public boolean addFromNode(Node node, int ordinal, AmqpVersion version)
+        throws AmqpParseException, AmqpTypeMappingException
+    {
+        NodeList nodeList = node.getChildNodes();
+        for (int i=0; i<nodeList.getLength(); i++)
+        {
+            Node childNode = nodeList.item(i);
+            if (childNode.getNodeName().compareTo(Utils.ELEMENT_CONSTANT) == 0)
+            {
+                String name = converter.prepareDomainName(Utils.getNamedAttribute(childNode, Utils.ATTRIBUTE_NAME));
+                String value = Utils.getNamedAttribute(childNode, Utils.ATTRIBUTE_VALUE);
+                // Find this name in the existing set of objects
+                boolean foundName = false;
+                Iterator<AmqpConstant> cItr = iterator();
+                while (cItr.hasNext() && !foundName)
+                {
+                    AmqpConstant thisConstant = cItr.next();
+                    if (name.compareTo(thisConstant.name) == 0)
+                    {
+                        foundName = true;
+                        thisConstant.versionSet.add(version);
+                        // Now, find the value in the map
+                        boolean foundValue = false;
+                        for (String thisValue : thisConstant.keySet())
+                        {
+                            if (value.compareTo(thisValue) == 0)
+                            {
+                                foundValue = true;
+                               // Add this version to existing version set.
+                                AmqpVersionSet versionSet = thisConstant.get(thisValue);
+                                versionSet.add(version);
+                            }
+                        }
+                        // Check that the value was found - if not, add it
+                        if (!foundValue)
+                        {
+                            thisConstant.put(value, new AmqpVersionSet(version));
+                        }              
+                    }
+                }
+                // Check that the name was found - if not, add it
+                if (!foundName)
+                {
+                    add(new AmqpConstant(name, value, version));
+                }
+           }
+        }
+        return true;
+    }
+    
+    /* (non-Javadoc)
+     * @see org.apache.qpid.gentools.Printable#print(java.io.PrintStream, int, int)
+     */
+    public void print(PrintStream out, int marginSize, int tabSize)
+    {
+        out.println(Utils.createSpaces(marginSize) + "Constants: ");
+        for (AmqpConstant thisAmqpConstant : this)
+        {
+        	thisAmqpConstant.print(out, marginSize, tabSize);
+        }
+    }
+    
+    /* (non-Javadoc)
+     * @see java.lang.Comparable#compareTo(java.lang.Object)
+     */
+    public int compareTo(AmqpConstantSet other)
+    {
+        int res = size() - other.size();
+        if (res != 0)
+            return res;
+        Iterator<AmqpConstant> cItr = iterator();
+        Iterator<AmqpConstant> oItr = other.iterator();
+        while (cItr.hasNext() && oItr.hasNext())
+        {
+            AmqpConstant constant = cItr.next();
+            AmqpConstant oConstant = oItr.next();
+            res = constant.compareTo(oConstant);
+            if (res != 0)
+                return res;
+        }
+        return 0;
+    }
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpDomain.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpDomain.java
new file mode 100644
index 0000000000..4796f31fb3
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpDomain.java
@@ -0,0 +1,78 @@
+/*
+ *
+ * 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.PrintStream;
+import java.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class AmqpDomain extends TreeMap<String, AmqpVersionSet> implements Printable
+{
+	public String domainName;
+
+	public AmqpDomain(String domainName)
+	{
+		this.domainName = domainName;
+	}
+
+	public void addDomain(String domainType, AmqpVersion version) throws AmqpParseException
+	{
+		AmqpVersionSet versionSet = get(domainType);
+		if (versionSet == null) // First time, create new entry
+		{
+			versionSet = new AmqpVersionSet();
+			put(domainType, versionSet);
+		}
+		versionSet.add(version);
+	}
+
+	public String getDomainType(AmqpVersion version)
+	    throws AmqpTypeMappingException
+	{
+		for (String thisDomainType : keySet())
+		{
+			AmqpVersionSet versionSet = get(thisDomainType);
+			if (versionSet.contains(version))
+				return thisDomainType;
+		} throw new AmqpTypeMappingException("Unable to find version " + version + ".");
+	}
+	
+	public boolean hasVersion(String type, AmqpVersion v)
+	{
+		AmqpVersionSet vs = get(type);
+		if (vs == null)
+			return false;
+		return vs.contains(v);
+	}
+	
+	public void print(PrintStream out, int marginSize, int tabSize)
+	{
+		String margin = Utils.createSpaces(marginSize);
+		String tab = Utils.createSpaces(tabSize);
+		out.println(margin + domainName + ":");
+		
+		for (String thisDomainType : keySet())
+		{
+			AmqpVersionSet vs = get(thisDomainType);
+			out.println(margin + tab + thisDomainType + " : " + vs.toString());
+		}
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpDomainMap.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpDomainMap.java
new file mode 100644
index 0000000000..7e2974a444
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpDomainMap.java
@@ -0,0 +1,119 @@
+/*
+ *
+ * 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.PrintStream;
+import java.util.TreeMap;
+
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+@SuppressWarnings("serial")
+public class AmqpDomainMap extends TreeMap<String, AmqpDomain> implements Printable, NodeAware
+{
+	public LanguageConverter converter;
+
+	public AmqpDomainMap(LanguageConverter converter)
+	{
+		this.converter = converter;
+		this.converter.setDomainMap(this);
+	}
+	
+	public boolean addFromNode(Node n, int o, AmqpVersion v)
+		throws AmqpParseException, AmqpTypeMappingException
+	{
+		NodeList nl = n.getChildNodes();
+		for (int i=0; i<nl.getLength(); i++)
+		{
+			Node c = nl.item(i);
+			// All versions 0.9 and greater use <domain> for all domains
+			if (c.getNodeName().compareTo(Utils.ELEMENT_DOMAIN) == 0)
+			{
+				String domainName = converter.prepareDomainName(Utils.getNamedAttribute(c, Utils.ATTRIBUTE_NAME));
+				String type = Utils.getNamedAttribute(c, Utils.ATTRIBUTE_TYPE);
+				AmqpDomain thisDomain = get(domainName);
+				if (thisDomain == null)
+				{
+					thisDomain = new AmqpDomain(domainName);
+					put(domainName, thisDomain);
+				}
+				thisDomain.addDomain(type, v);
+			}
+			// Version(s) 0.8 and earlier use <domain> for all complex domains and use
+			// attribute <field type=""...> for simple types. Add these simple types to
+			// domain list - but beware of duplicates!
+			else if (c.getNodeName().compareTo(Utils.ELEMENT_FIELD) == 0)
+			{
+				try
+				{
+					String type = converter.prepareDomainName(Utils.getNamedAttribute(c, Utils.ATTRIBUTE_TYPE));
+					AmqpDomain thisDomain = get(type);
+					if (thisDomain == null)
+					{
+						thisDomain = new AmqpDomain(type);
+						put(type, thisDomain);
+					}
+					if (!thisDomain.hasVersion(type, v))
+						thisDomain.addDomain(type, v);
+				}
+				catch (AmqpParseException e) {} // Ignore fields without type attribute
+			}
+			else if (c.getNodeName().compareTo(Utils.ELEMENT_CLASS) == 0 ||
+					 c.getNodeName().compareTo(Utils.ELEMENT_METHOD) == 0)
+			{
+				addFromNode(c, 0, v);
+			}
+		}
+		return true;
+	}
+
+	public String getDomainType(String domainName, AmqpVersion version)
+	    throws AmqpTypeMappingException
+	{
+		AmqpDomain domainType = get(domainName);
+		// For AMQP 8.0, primitive types were not described as domains, so
+		// return itself as the type.
+		if (domainType == null)
+		{
+			return domainName;
+		}
+		try
+		{
+			return domainType.getDomainType(version);
+		}
+		catch (AmqpTypeMappingException e)
+		{
+			throw new AmqpTypeMappingException("Unable to find domain type for domain \"" + domainName +
+				"\" version " + version + ".");
+		}
+	}
+	
+	
+	public void print(PrintStream out, int marginSize, int tabSize)
+	{
+        out.println(Utils.createSpaces(marginSize) + "Domain Map:");
+        for (String thisDomainName : keySet())
+		{
+			AmqpDomain domain = get(thisDomainName);
+			domain.print(out, marginSize + tabSize, tabSize);
+		}
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpDomainVersionMap.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpDomainVersionMap.java
new file mode 100644
index 0000000000..f91d98bfe7
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpDomainVersionMap.java
@@ -0,0 +1,58 @@
+/*
+ *
+ * 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.util.ArrayList;
+import java.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class AmqpDomainVersionMap extends TreeMap<String, AmqpVersionSet> implements VersionConsistencyCheck
+{	
+	public boolean isVersionConsistent(AmqpVersionSet globalVersionSet)
+	{
+		if (size() != 1)
+			return false;
+		return get(firstKey()).equals(globalVersionSet);
+	}
+	
+	public boolean removeVersion(AmqpVersion version)
+	{
+		Boolean res = false;
+		ArrayList<String> removeList = new ArrayList<String>();
+		for (String domainName : keySet())
+		{
+			AmqpVersionSet versionSet = get(domainName);
+			if (versionSet.contains(version))
+			{
+				versionSet.remove(version);
+				if (versionSet.isEmpty())
+					removeList.add(domainName);
+				res = true;
+			}
+		}
+		// Get rid of domains no longer in use
+		for (String domainName : removeList)
+		{
+			remove(domainName);
+		}
+		return res;
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpField.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpField.java
new file mode 100644
index 0000000000..e1177e0154
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpField.java
@@ -0,0 +1,156 @@
+/*
+ *
+ * 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.PrintStream;
+import java.util.ArrayList;
+
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+public class AmqpField implements Printable, NodeAware, VersionConsistencyCheck
+{
+	public LanguageConverter converter;
+	public AmqpVersionSet versionSet;
+	public AmqpDomainVersionMap domainMap;
+	public AmqpOrdinalVersionMap ordinalMap;
+	public String name;
+	
+	public AmqpField(String name, LanguageConverter converter)
+	{
+		this.name = name;
+		this.converter = converter;
+		versionSet = new AmqpVersionSet();
+		domainMap = new AmqpDomainVersionMap();
+		ordinalMap = new AmqpOrdinalVersionMap();
+	}
+
+	public boolean addFromNode(Node fieldNode, int ordinal, AmqpVersion version)
+		throws AmqpParseException, AmqpTypeMappingException
+	{
+		versionSet.add(version);
+		String domainType;
+		// Early versions of the spec (8.0) used the "type" attribute instead of "domain" for some fields.
+		try
+		{
+			domainType = converter.prepareDomainName(Utils.getNamedAttribute(fieldNode, Utils.ATTRIBUTE_DOMAIN));
+		}
+		catch (AmqpParseException e)
+		{
+			domainType = converter.prepareDomainName(Utils.getNamedAttribute(fieldNode, Utils.ATTRIBUTE_TYPE));
+		}
+		AmqpVersionSet thisVersionList = domainMap.get(domainType);
+		if (thisVersionList == null) // First time, create new entry
+		{
+			thisVersionList = new AmqpVersionSet();
+			domainMap.put(domainType, thisVersionList);
+		}
+		thisVersionList.add(version);
+		thisVersionList = ordinalMap.get(ordinal);
+		if (thisVersionList == null) // First time, create new entry
+		{
+			thisVersionList = new AmqpVersionSet();
+			ordinalMap.put(ordinal, thisVersionList);
+		}
+		thisVersionList.add(version);
+		NodeList nList = fieldNode.getChildNodes();
+		for (int i=0; i<nList.getLength(); i++)
+		{
+			Node child = nList.item(i);
+			if (child.getNodeName().compareTo(Utils.ELEMENT_CODEGEN) == 0)
+			{
+				String value = Utils.getNamedAttribute(child, Utils.ATTRIBUTE_VALUE);
+				if (value.compareTo("no-gen") == 0)
+					return false;
+			}
+		}
+		return true;
+	}
+	
+	public void removeVersion(AmqpVersion version)
+	{
+		domainMap.removeVersion(version);
+		ordinalMap.removeVersion(version);
+		versionSet.remove(version);
+	}
+	
+	public boolean isCodeTypeConsistent(LanguageConverter converter)
+	    throws AmqpTypeMappingException
+	{
+		if (domainMap.size() == 1)
+			return true; // By definition
+		ArrayList<String> codeTypeList = new ArrayList<String>();
+		for (String thisDomainName : domainMap.keySet())
+		{
+			AmqpVersionSet versionSet = domainMap.get(thisDomainName);
+			String codeType = converter.getGeneratedType(thisDomainName, versionSet.first());
+			if (!codeTypeList.contains(codeType))
+				codeTypeList.add(codeType);
+		}
+		return codeTypeList.size() == 1;
+	}
+	
+	public boolean isConsistent(Generator generator)
+        throws AmqpTypeMappingException
+	{
+		if (!isCodeTypeConsistent(generator))
+			return false;
+		if (ordinalMap.size() != 1)
+			return false;
+		// Since the various doamin names map to the same code type, add the version occurrences
+		// across all domains to see we have all possible versions covered
+		int vCntr = 0;
+		for (String thisDomainName : domainMap.keySet())
+		{
+			vCntr += domainMap.get(thisDomainName).size();
+		}
+		return vCntr == generator.globalVersionSet.size();
+	}
+	
+	public void print(PrintStream out, int marginSize, int tabSize)
+	{
+		String margin = Utils.createSpaces(marginSize);
+		out.println(margin + "[F] " + name + ": " + versionSet);
+
+		for (Integer thisOrdinal : ordinalMap.keySet())
+		{
+			AmqpVersionSet versionList = ordinalMap.get(thisOrdinal);
+			out.println(margin + "  [O] " + thisOrdinal + " : " + versionList.toString());
+		}
+
+		for (String thisDomainName : domainMap.keySet())
+		{
+			AmqpVersionSet versionList = domainMap.get(thisDomainName);
+			out.println(margin + "  [D] " + thisDomainName + " : " + versionList.toString());
+		}
+	}
+	
+	public boolean isVersionConsistent(AmqpVersionSet globalVersionSet)
+	{
+		if (!versionSet.equals(globalVersionSet))
+			return false;
+		if (!domainMap.isVersionConsistent(globalVersionSet))
+			return false;
+		if (!ordinalMap.isVersionConsistent(globalVersionSet))
+			return false;
+		return true;
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpFieldMap.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpFieldMap.java
new file mode 100644
index 0000000000..c91ec3d623
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpFieldMap.java
@@ -0,0 +1,348 @@
+/*
+ *
+ * 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.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class AmqpFieldMap extends TreeMap<String, AmqpField> implements VersionConsistencyCheck
+{
+	public void removeVersion(AmqpVersion version)
+	{
+		String[] fieldNameArray = new String[size()];
+		keySet().toArray(fieldNameArray);
+		for (String fieldName : fieldNameArray)
+		{
+			get(fieldName).removeVersion(version);
+			remove(fieldName);
+		}
+	}
+	
+	public AmqpFieldMap getFieldMapForOrdinal(int ordinal)
+	{
+		AmqpFieldMap newMap = new AmqpFieldMap();
+		for (String thisFieldName: keySet())
+		{
+			AmqpField field = get(thisFieldName);
+			TreeMap<Integer, AmqpVersionSet> ordinalMap = field.ordinalMap;
+			AmqpVersionSet ordinalVersions = ordinalMap.get(ordinal);
+			if (ordinalVersions != null)
+			{
+				newMap.put(field.name, field);
+			}
+		}
+		return newMap;
+	}
+	
+	public AmqpOrdinalFieldMap getMapForVersion(AmqpVersion version, boolean codeTypeFlag,
+		LanguageConverter converter)
+		throws AmqpTypeMappingException
+	{
+		// TODO: REVIEW THIS! There may be a bug here that affects C++ generation (only with >1 version)...
+		// If version == null (a common scenario) then the version map is built up on the
+		// basis of first found item, and ignores other version variations.
+		// This should probably be disallowed by throwing an NPE, as AmqpOrdinalFieldMap cannot
+		// represent these possibilities.
+		// *OR*
+		// Change the structure of AmqpOrdianlFieldMap to allow for the various combinations that
+		// will result from version variation - but that is what AmqpFieldMap is... :-$
+		AmqpOrdinalFieldMap ordinalFieldMap = new AmqpOrdinalFieldMap();
+		for (String thisFieldName: keySet())
+		{
+			AmqpField field = get(thisFieldName);
+			if (version == null || field.versionSet.contains(version))
+			{
+				// 1. Search for domain name in field domain map with version that matches
+				String domain = "";
+				boolean dFound = false;
+				for (String thisDomainName : field.domainMap.keySet())
+				{
+					domain = thisDomainName;
+					AmqpVersionSet versionSet = field.domainMap.get(domain);
+					if (version == null || versionSet.contains(version))
+					{
+						if (codeTypeFlag)
+							domain = converter.getGeneratedType(domain, version);
+						dFound = true;
+					}
+				}
+				
+				// 2. Search for ordinal in field ordianl map with version that matches
+				int ordinal = -1;
+				boolean oFound = false;
+				for (Integer thisOrdinal : field.ordinalMap.keySet())
+				{
+					ordinal = thisOrdinal;
+					AmqpVersionSet versionSet = field.ordinalMap.get(ordinal);
+					if (version == null || versionSet.contains(version))
+						oFound = true;
+				}
+				
+				if (dFound && oFound)
+				{
+					String[] fieldDomainPair = {field.name, domain};
+					ordinalFieldMap.put(ordinal, fieldDomainPair);
+				}
+			}
+		}
+		return ordinalFieldMap;
+	}
+		
+	public boolean isDomainConsistent(Generator generator, AmqpVersionSet versionSet)
+        throws AmqpTypeMappingException
+	{
+		if (size() != 1) // Only one field for this ordinal
+			return false;
+		return get(firstKey()).isConsistent(generator);
+	}
+	
+	public int getNumFields(AmqpVersion version)
+	{
+		int fCntr = 0;
+		for (String thisFieldName : keySet())
+		{
+			AmqpField field = get(thisFieldName);
+			if (field.versionSet.contains(version))
+				fCntr++;
+		}
+		return fCntr;
+	}
+	
+	public String parseFieldMap(Method commonGenerateMethod, Method mangledGenerateMethod,
+		int indentSize, int tabSize, LanguageConverter converter)
+        throws AmqpTypeMappingException, IllegalAccessException, InvocationTargetException
+	{
+		String indent = Utils.createSpaces(indentSize);
+		String cr = Utils.lineSeparator;
+		StringBuffer sb = new StringBuffer();
+		
+		if (commonGenerateMethod == null)
+		{
+			// Generate warnings in code if required methods are null.
+			sb.append(indent + "/*********************************************************" + cr);
+			sb.append(indent + " * WARNING: Generated code could be missing." + cr);
+			sb.append(indent + " * In call to parseFieldMap(), generation method was null." + cr);
+			sb.append(indent + " * Check for NoSuchMethodException on startup." + cr);
+			sb.append(indent + " *********************************************************/" + cr);
+		}
+
+		Iterator<String> itr = keySet().iterator();
+		while (itr.hasNext())
+		{
+			String fieldName = itr.next();
+			AmqpField field = get(fieldName);
+			if (field.isCodeTypeConsistent(converter))
+			{
+				// All versions identical - Common declaration
+				String domainName = field.domainMap.firstKey();
+				AmqpVersionSet versionSet = field.domainMap.get(domainName);
+				String codeType = converter.getGeneratedType(domainName, versionSet.first());
+				if (commonGenerateMethod != null)
+					sb.append(commonGenerateMethod.invoke(converter, codeType, field, versionSet,
+					    indentSize, tabSize, itr.hasNext()));
+			}
+			else if (mangledGenerateMethod != null) // Version-mangled
+			{
+				sb.append(mangledGenerateMethod.invoke(converter, field, indentSize, tabSize,
+					itr.hasNext()));
+			}
+		}
+		return sb.toString();		
+	}
+	
+	public String parseFieldMapOrdinally(Method generateMethod, Method bitGenerateMethod,
+		int indentSize, int tabSize, Generator codeGenerator)
+	    throws AmqpTypeMappingException, IllegalAccessException, InvocationTargetException
+	{
+		String indent = Utils.createSpaces(indentSize);
+		String cr = Utils.lineSeparator;
+		StringBuffer sb = new StringBuffer();	    
+
+		// Generate warnings in code if required methods are null.
+		if (generateMethod == null || bitGenerateMethod == null)
+		{
+			sb.append(indent + "/***********************************************" + cr);
+			sb.append(indent + " * WARNING: In call to parseFieldMapOrdinally():" + cr);
+			if (generateMethod == null)
+				sb.append(indent + " *  => generateMethod is null." + cr);
+			if (bitGenerateMethod == null)
+				sb.append(indent + " *  => bitGenerateMethod is null." + cr);
+			sb.append(indent + " * Generated code could be missing." + cr);
+			sb.append(indent + " * Check for NoSuchMethodException on startup." + cr);
+			sb.append(indent + " ***********************************************/" + cr);
+		}
+
+		/* We must process elements in ordinal order because adjacent booleans (bits)
+		 * must be combined into a single byte (in groups of up to 8). Start with shared
+		 * declarations until an ordinal divergence is found. (For most methods where
+		 * there is no difference between versions, this will simplify the generated
+		 * code. */
+
+		ArrayList<String> bitFieldList = new ArrayList<String>();
+		boolean ordinalDivergenceFlag = false;
+		int ordinal = 0;
+		while (ordinal < size() && !ordinalDivergenceFlag)
+		{
+			/* Since the getFieldMapOrdinal() function may map more than one Field to
+			 * an ordinal, the number of ordinals may be less than the total number of
+			 * fields in the fieldMap. Check for empty fieldmaps... */
+			AmqpFieldMap ordinalFieldMap = getFieldMapForOrdinal(ordinal);
+			if (ordinalFieldMap.size() > 0)
+			{
+				if (ordinalFieldMap.isDomainConsistent(codeGenerator, codeGenerator.globalVersionSet))
+				{
+					String fieldName = ordinalFieldMap.firstKey();
+					String domain = ordinalFieldMap.get(fieldName).domainMap.firstKey();
+					String domainType = codeGenerator.getDomainType(domain,
+						codeGenerator.globalVersionSet.first());
+					if (domainType.compareTo("bit") == 0)
+						bitFieldList.add(fieldName);
+					else if (bitFieldList.size() > 0)
+					{
+						// End of bit types - handle deferred bit type generation
+						if (bitGenerateMethod != null)
+							sb.append(bitGenerateMethod.invoke(codeGenerator, bitFieldList, ordinal,
+								indentSize, tabSize));
+						bitFieldList.clear();
+					}
+					if (!ordinalDivergenceFlag)
+					{
+						// Defer generation of bit types until all adjacent bits have been
+						// accounted for.
+						if (bitFieldList.size() == 0 && generateMethod != null)
+							sb.append(generateMethod.invoke(codeGenerator, domainType, fieldName, ordinal,
+								indentSize, tabSize));
+					}
+					ordinal++;
+				}
+				else
+				{
+					ordinalDivergenceFlag = true;
+				}
+			}
+		}
+
+		// Check if there is still more to do under a version-specific breakout
+		if (ordinalDivergenceFlag && ordinal< size())
+		{
+			// 1. Cycle through all versions in order, create outer if(version) structure
+			AmqpVersion[] versionArray = new AmqpVersion[codeGenerator.globalVersionSet.size()];
+			codeGenerator.globalVersionSet.toArray(versionArray);
+			for (int v=0; v<versionArray.length; v++)
+			{
+				sb.append(indent);
+				if (v > 0)
+					sb.append("else ");
+				sb.append("if (major == " + versionArray[v].getMajor() + " && minor == " +
+					versionArray[v].getMinor() + ")" + cr);
+				sb.append(indent + "{" + cr);
+				
+				// 2. Cycle though each ordinal from where we left off in the loop above.
+				ArrayList<String> bitFieldList2 = new ArrayList<String>(bitFieldList);
+				for (int o = ordinal; o<size(); o++)
+				{
+					AmqpFieldMap ordinalFieldMap = getFieldMapForOrdinal(o);
+					if (ordinalFieldMap.size() > 0)
+					{
+						// 3. Cycle through each of the fields that have this ordinal.
+						Iterator<String> i = ordinalFieldMap.keySet().iterator();
+						while (i.hasNext())
+						{
+							String fieldName = i.next();
+							AmqpField field = ordinalFieldMap.get(fieldName);
+
+							// 4. Some fields may have more than one ordinal - match by both
+							//    ordinal and version.
+							Iterator<Integer> j = field.ordinalMap.keySet().iterator();
+							while (j.hasNext())
+							{
+								int thisOrdinal = j.next();
+								AmqpVersionSet v1 = field.ordinalMap.get(thisOrdinal);
+								if (thisOrdinal == o && v1.contains(versionArray[v]))
+								{
+									// 5. Now get the domain for this version
+									int domainCntr = 0;
+									Iterator<String> k = field.domainMap.keySet().iterator();
+									while (k.hasNext())
+									{
+										// Mangle domain-divergent field names
+										String mangledFieldName = fieldName;
+										if (field.domainMap.size() > 1)
+											mangledFieldName += "_" + (domainCntr++);
+										String domainName = k.next();
+										AmqpVersionSet v2 = field.domainMap.get(domainName);
+										if (v2.contains(versionArray[v]))
+										{
+											// 6. (Finally!!) write the declaration
+											String domainType = codeGenerator.getDomainType(domainName,
+												versionArray[v]);
+											if (domainType.compareTo("bit") == 0)
+												bitFieldList2.add(mangledFieldName);
+											else if (bitFieldList2.size() > 0)
+											{
+												// End of bit types - handle deferred bit type generation
+												if (bitGenerateMethod != null)
+													sb.append(bitGenerateMethod.invoke(codeGenerator,
+														bitFieldList2, o, indentSize + tabSize,
+														tabSize));
+												bitFieldList2.clear();
+											}
+											// Defer generation of bit types until all adjacent bits have
+											// been accounted for.
+											if (bitFieldList2.size() == 0 && generateMethod != null)
+												sb.append(generateMethod.invoke(codeGenerator, domainType,
+														mangledFieldName, o, indentSize + tabSize, tabSize));
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+				// Check for remaining deferred bits
+				if (bitFieldList2.size() > 0 && bitGenerateMethod != null)
+					sb.append(bitGenerateMethod.invoke(codeGenerator, bitFieldList2, size(),
+						indentSize + tabSize, tabSize));
+				sb.append(indent + "}" + cr);
+			}
+		}
+		// Check for remaining deferred bits
+		else if (bitFieldList.size() > 0 && bitGenerateMethod != null)
+			sb.append(bitGenerateMethod.invoke(codeGenerator, bitFieldList, size(),
+				indentSize, tabSize));
+		return sb.toString();		
+	}
+	
+	public boolean isVersionConsistent(AmqpVersionSet globalVersionSet)
+	{
+		for (String thisFieldName : keySet())
+		{
+			AmqpField field = get(thisFieldName);
+			if (!field.isVersionConsistent(globalVersionSet))
+				return false;
+		}
+		return true;
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpFlagMap.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpFlagMap.java
new file mode 100644
index 0000000000..3f86326ce2
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpFlagMap.java
@@ -0,0 +1,84 @@
+/*
+ *
+ * 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.util.ArrayList;
+import java.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class AmqpFlagMap extends TreeMap<Boolean, AmqpVersionSet> implements VersionConsistencyCheck
+{
+	public boolean isSet()
+	{
+		return containsKey(true);
+	}
+
+	public boolean isSet(AmqpVersion version)
+	{
+	    return containsKey(true) && get(true).contains(version);
+	}
+
+        public void setFlagForVersion(boolean flag, AmqpVersion version) {
+	    if (get(flag) == null) {
+		put(flag, new AmqpVersionSet(version));
+	    } else {
+		get(flag).add(version);
+	    }
+	}
+    
+	public String toString()
+	{
+		AmqpVersionSet versionSet = get(true);
+		if (versionSet != null)
+			return versionSet.toString();
+		return "";
+	}
+	
+	public boolean isVersionConsistent(AmqpVersionSet globalVersionSet)
+	{
+		if (size() != 1)
+			return false;
+		return get(firstKey()).equals(globalVersionSet);
+	}
+	
+	public boolean removeVersion(AmqpVersion version)
+	{
+		Boolean res = false;
+		ArrayList<Boolean> removeList = new ArrayList<Boolean>();
+		for (Boolean flag : keySet())
+		{
+			AmqpVersionSet versionSet = get(flag);
+			if (versionSet.contains(version))
+			{
+				versionSet.remove(version);
+				if (versionSet.isEmpty())
+					removeList.add(flag);
+				res = true;
+			}
+		}
+		// Get rid of flags no longer in use
+		for (Boolean flag : removeList)
+		{
+			remove(flag);
+		}
+		return res;
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpMethod.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpMethod.java
new file mode 100644
index 0000000000..f3c5bdd935
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpMethod.java
@@ -0,0 +1,211 @@
+/*
+ *
+ * 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.PrintStream;
+
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Element;
+
+public class AmqpMethod implements Printable, NodeAware, VersionConsistencyCheck
+{
+	public LanguageConverter converter;
+	public AmqpVersionSet versionSet;
+	public AmqpFieldMap fieldMap;
+	public String name;
+	public AmqpOrdinalVersionMap indexMap;
+	public AmqpFlagMap clientMethodFlagMap; // Method called on client (<chassis name="server"> in XML)
+	public AmqpFlagMap serverMethodFlagMap; // Method called on server (<chassis name="client"> in XML)
+        public AmqpFlagMap isResponseFlagMap;
+
+	public AmqpMethod(String name, LanguageConverter converter)
+	{
+		this.name = name;
+		this.converter = converter;
+		versionSet = new AmqpVersionSet();
+		fieldMap = new AmqpFieldMap();
+		indexMap = new AmqpOrdinalVersionMap();
+		clientMethodFlagMap = new AmqpFlagMap();
+		serverMethodFlagMap = new AmqpFlagMap();
+		isResponseFlagMap = new AmqpFlagMap();
+	}
+
+        public boolean isResponse(AmqpVersion version) {
+	    return (version == null) ? isResponseFlagMap.isSet() : isResponseFlagMap.isSet(version);
+	}
+    
+        /** Check if this method is named as a response by any other method in the class. */
+        public void checkForResponse(Element methodElement, AmqpVersion version) {
+	    Element clazz = (Element)methodElement.getParentNode();
+	    String methodName = methodElement.getAttribute("name");
+	    NodeList methods = clazz.getElementsByTagName("method");
+	    for (int i=0; i<methods.getLength(); ++i) {
+		Element method = (Element)methods.item(i);
+		NodeList responses = method.getElementsByTagName("response");
+		for (int j =0; j<responses.getLength(); ++j) {
+		    Element response = (Element)responses.item(j);
+		    if (methodName.equals(response.getAttribute("name"))) {
+			isResponseFlagMap.setFlagForVersion(true, version);
+		    }
+		}
+	    }
+        }
+    
+	public boolean addFromNode(Node methodNode, int ordinal, AmqpVersion version)
+		throws AmqpParseException, AmqpTypeMappingException
+	{
+		versionSet.add(version);
+		boolean serverChassisFlag = false;
+		boolean clientChassisFlag = false;
+		int index = Utils.getNamedIntegerAttribute(methodNode, "index");
+		AmqpVersionSet indexVersionSet = indexMap.get(index);
+		if (indexVersionSet != null)
+			indexVersionSet.add(version);
+		else
+		{
+			indexVersionSet = new AmqpVersionSet();
+			indexVersionSet.add(version);
+			indexMap.put(index, indexVersionSet);
+		}
+		NodeList nList = methodNode.getChildNodes();
+		int fieldCntr = fieldMap.size();
+		for (int i=0; i<nList.getLength(); i++)
+		{
+			Node child = nList.item(i);
+			if (child.getNodeName().compareTo(Utils.ELEMENT_FIELD) == 0)
+			{
+				String fieldName = converter.prepareDomainName(Utils.getNamedAttribute(child,
+						Utils.ATTRIBUTE_NAME));
+				AmqpField thisField = fieldMap.get(fieldName);
+				if (thisField == null)
+				{
+					thisField = new AmqpField(fieldName, converter);
+					fieldMap.put(fieldName, thisField);
+				}
+				if (!thisField.addFromNode(child, fieldCntr++, version))
+				{
+					String className = converter.prepareClassName(Utils.getNamedAttribute(methodNode.getParentNode(),
+							Utils.ATTRIBUTE_NAME));
+					String methodName = converter.prepareMethodName(Utils.getNamedAttribute(methodNode,
+							Utils.ATTRIBUTE_NAME));
+					System.out.println("INFO: Generation supression tag found for field " +
+							className + "." + methodName + "." + fieldName + " - removing.");
+					thisField.removeVersion(version);
+					fieldMap.remove(fieldName);
+				}
+			}
+			else if (child.getNodeName().compareTo(Utils.ELEMENT_CHASSIS) == 0)
+			{
+				String chassisName = Utils.getNamedAttribute(child, Utils.ATTRIBUTE_NAME);
+				if (chassisName.compareTo("server") == 0)
+					serverChassisFlag = true;
+				else if (chassisName.compareTo("client") == 0)
+					clientChassisFlag = true;
+			}
+			else if (child.getNodeName().compareTo(Utils.ELEMENT_CODEGEN) == 0)
+			{
+				String value = Utils.getNamedAttribute(child, Utils.ATTRIBUTE_VALUE);
+				if (value.compareTo("no-gen") == 0)
+					return false;
+			}
+		}
+		checkForResponse((Element)methodNode, version);
+		processChassisFlags(serverChassisFlag, clientChassisFlag, version);
+		return true;
+	}
+	
+	public void removeVersion(AmqpVersion version)
+	{
+		clientMethodFlagMap.removeVersion(version);
+		serverMethodFlagMap.removeVersion(version);
+		isResponseFlagMap.removeVersion(version);
+		indexMap.removeVersion(version);
+		fieldMap.removeVersion(version);
+		versionSet.remove(version);
+	}
+	
+	public void print(PrintStream out, int marginSize, int tabSize)
+	{
+		String margin = Utils.createSpaces(marginSize);
+		String tab = Utils.createSpaces(tabSize);
+		out.println(margin + "[M] " + name + " {" + (serverMethodFlagMap.isSet() ? "S " +
+			serverMethodFlagMap + (clientMethodFlagMap.isSet() ? ", " : "") : "") +
+			(clientMethodFlagMap.isSet() ? "C " + clientMethodFlagMap : "") + "}" + ": " +
+			versionSet);
+		
+		for (Integer thisIndex : indexMap.keySet())
+		{
+			AmqpVersionSet indexVersionSet = indexMap.get(thisIndex);
+			out.println(margin + tab + "[I] " + thisIndex + indexVersionSet);
+		}
+		
+		for (String thisFieldName : fieldMap.keySet())
+		{
+			AmqpField thisField = fieldMap.get(thisFieldName);
+			thisField.print(out, marginSize + tabSize, tabSize);
+		}
+	}
+	
+	protected void processChassisFlags(boolean serverFlag, boolean clientFlag, AmqpVersion version)
+	{
+	    serverMethodFlagMap.setFlagForVersion(serverFlag, version);
+	    clientMethodFlagMap.setFlagForVersion(clientFlag, version);
+	}
+	
+	public AmqpOverloadedParameterMap getOverloadedParameterLists(AmqpVersionSet globalVersionSet,
+		Generator generator)
+		throws AmqpTypeMappingException
+	{
+		AmqpOverloadedParameterMap parameterVersionMap = new AmqpOverloadedParameterMap();
+		for (AmqpVersion thisVersion : globalVersionSet)
+		{
+			AmqpOrdinalFieldMap ordinalFieldMap = fieldMap.getMapForVersion(thisVersion, true, generator);
+			AmqpVersionSet methodVersionSet = parameterVersionMap.get(ordinalFieldMap);
+			if (methodVersionSet == null)
+			{
+				methodVersionSet = new AmqpVersionSet();
+				methodVersionSet.add(thisVersion);
+				parameterVersionMap.put(ordinalFieldMap, methodVersionSet);
+			}
+			else
+			{
+				methodVersionSet.add(thisVersion);
+			}
+		}
+		return parameterVersionMap;
+	}
+		
+	public boolean isVersionConsistent(AmqpVersionSet globalVersionSet)
+	{
+		if (!versionSet.equals(globalVersionSet))
+			return false;
+		if (!clientMethodFlagMap.isVersionConsistent(globalVersionSet))
+			return false;
+		if (!serverMethodFlagMap.isVersionConsistent(globalVersionSet))
+			return false;
+		if (!indexMap.isVersionConsistent(globalVersionSet))
+			return false;
+		if (!fieldMap.isVersionConsistent(globalVersionSet))
+			return false;
+		return true;
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpMethodMap.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpMethodMap.java
new file mode 100644
index 0000000000..59eedd2a2b
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpMethodMap.java
@@ -0,0 +1,36 @@
+/*
+ *
+ * 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.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class AmqpMethodMap extends TreeMap<String, AmqpMethod>
+{
+	public void removeVersion(AmqpVersion version)
+	{
+		for (String methodName : keySet())
+		{
+			get(methodName).removeVersion(version);
+		}
+	}
+
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpModel.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpModel.java
new file mode 100644
index 0000000000..721247a4b2
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpModel.java
@@ -0,0 +1,80 @@
+/*
+ *
+ * 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.PrintStream;
+
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+public class AmqpModel implements Printable, NodeAware
+{
+	public LanguageConverter converter;
+	public AmqpClassMap classMap;
+
+	public AmqpModel(LanguageConverter converter)
+	{
+		this.converter = converter;
+		this.converter.setModel(this);
+		classMap = new AmqpClassMap();
+	}
+
+	public boolean addFromNode(Node n, int o, AmqpVersion v)
+		throws AmqpParseException, AmqpTypeMappingException
+	{
+		NodeList nList = n.getChildNodes();
+		int eCntr = 0;
+		for (int i=0; i<nList.getLength(); i++)
+		{
+			Node c = nList.item(i);
+			if (c.getNodeName().compareTo(Utils.ELEMENT_CLASS) == 0)
+			{
+				String className = converter.prepareClassName(Utils.getNamedAttribute(c, Utils.ATTRIBUTE_NAME));
+				AmqpClass thisClass = classMap.get(className);
+				if (thisClass == null)
+				{
+					thisClass = new AmqpClass(className, converter);
+					classMap.put(className, thisClass);
+				}
+				if (!thisClass.addFromNode(c, eCntr++, v))
+				{
+					System.out.println("INFO: Generation supression tag found for class " + className + " - removing.");
+					thisClass.removeVersion(v);
+					classMap.remove(className);
+				}
+			}
+		}
+		return true;
+	}
+	
+	public void print(PrintStream out, int marginSize, int tabSize)
+	{
+		out.println(Utils.createSpaces(marginSize) +
+			"[C]=class; [M]=method; [F]=field; [D]=domain; [I]=index; [O]=ordinal" + Utils.lineSeparator);
+		out.println(Utils.createSpaces(marginSize) + "Model:");
+
+		for (String thisClassName : classMap.keySet())
+		{
+			AmqpClass thisClass = classMap.get(thisClassName);
+			thisClass.print(out, marginSize + tabSize, tabSize);
+		}
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpOrdinalFieldMap.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpOrdinalFieldMap.java
new file mode 100644
index 0000000000..34d3b7ca5f
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpOrdinalFieldMap.java
@@ -0,0 +1,89 @@
+/*
+ *
+ * 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.util.Iterator;
+import java.util.Set;
+import java.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class AmqpOrdinalFieldMap extends TreeMap<Integer, String[]> implements Comparable
+{
+	protected static final int FIELD_DOMAIN = 1;
+	protected boolean codeTypeFlag = false;
+	
+	public int compareTo(Object obj)
+	{
+		AmqpOrdinalFieldMap o = (AmqpOrdinalFieldMap)obj;
+		Set<Integer> thisKeySet = keySet();
+		Set<Integer> oKeySet = o.keySet();
+		if (!thisKeySet.equals(oKeySet)) // Not equal, but why?
+		{
+			// Size difference
+			int sizeDiff = thisKeySet.size() - oKeySet.size(); // -ve if this < other
+			if (sizeDiff != 0)
+				return sizeDiff;
+			// Conetent difference
+			Iterator<Integer> itr = thisKeySet.iterator();
+			Iterator<Integer> oItr = oKeySet.iterator();
+			while (itr.hasNext() && oItr.hasNext())
+			{
+				int diff = itr.next() - oItr.next(); // -ve if this < other
+				if (diff != 0)
+					return diff;
+			}
+			// We should never get here...
+			System.err.println("AmqpOrdinalFieldMap.compareTo(): " +
+				"WARNING - unable to find cause of keySet difference.");
+		}
+		// Keys are equal, now check the String[]s
+		Iterator<Integer> itr = thisKeySet.iterator();
+		Iterator<Integer> oItr = oKeySet.iterator();
+		while (itr.hasNext() && oItr.hasNext())
+		{
+			String[] thisPair = get(itr.next());
+			String[] oPair = o.get(oItr.next());
+			// Size difference
+			int sizeDiff = thisPair.length - oPair.length; // -ve if this < other
+			if (sizeDiff != 0)
+				return sizeDiff;
+			// Conetent difference
+			for (int i=0; i<thisPair.length; i++)
+			{
+				int diff = thisPair[i].compareTo(oPair[i]);
+				if (diff != 0)
+					return diff;
+			}
+		}
+		return 0;
+	}
+	
+	public String toString()
+	{
+		StringBuffer sb = new StringBuffer();
+		for (Integer thisOrdinal : keySet())
+		{
+			String[] pair = get(thisOrdinal);
+			sb.append("[" + thisOrdinal + "] " + pair[0] + " : " + pair[1] + Utils.lineSeparator);
+		}
+		return sb.toString();
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpOrdinalVersionMap.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpOrdinalVersionMap.java
new file mode 100644
index 0000000000..3706c9391d
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpOrdinalVersionMap.java
@@ -0,0 +1,72 @@
+/*
+ *
+ * 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.util.ArrayList;
+import java.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class AmqpOrdinalVersionMap extends TreeMap<Integer, AmqpVersionSet> implements VersionConsistencyCheck
+{
+	public boolean isVersionConsistent(AmqpVersionSet globalVersionSet)
+	{
+		if (size() != 1)
+			return false;
+		return get(firstKey()).equals(globalVersionSet);
+	}
+    
+    public int getOrdinal(AmqpVersion version)
+    throws AmqpTypeMappingException
+    {
+    	for (Integer thisOrdinal : keySet())
+        {
+            AmqpVersionSet versionSet = get(thisOrdinal);
+            if (versionSet.contains(version))
+                return thisOrdinal;
+        }
+        throw new AmqpTypeMappingException("Unable to locate version " + version + " in ordianl version map.");
+    }
+	
+	public boolean removeVersion(AmqpVersion version)
+	{
+		Boolean res = false;
+		ArrayList<Integer> removeList = new ArrayList<Integer>();
+		for (Integer ordinal : keySet())
+		{
+			AmqpVersionSet versionSet = get(ordinal);
+			if (versionSet.contains(version))
+			{
+				versionSet.remove(version);
+				if (versionSet.isEmpty())
+				{
+					removeList.add(ordinal);
+				}
+				res = true;
+			}
+		}
+		// Get rid of ordinals no longer in use
+		for (Integer ordinal : removeList)
+		{
+			remove(ordinal);
+		}
+		return res;
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpOverloadedParameterMap.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpOverloadedParameterMap.java
new file mode 100644
index 0000000000..10978d0e4a
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpOverloadedParameterMap.java
@@ -0,0 +1,29 @@
+/*
+ *
+ * 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.util.TreeMap;
+
+@SuppressWarnings("serial")
+public class AmqpOverloadedParameterMap extends TreeMap<AmqpOrdinalFieldMap, AmqpVersionSet>
+{
+
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpParseException.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpParseException.java
new file mode 100644
index 0000000000..4d9f495390
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpParseException.java
@@ -0,0 +1,30 @@
+/*
+ *
+ * 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;
+
+@SuppressWarnings("serial")
+public class AmqpParseException extends Exception
+{
+	public AmqpParseException(String msg)
+	{
+		super(msg);
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpTemplateException.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpTemplateException.java
new file mode 100644
index 0000000000..b1e6f3d712
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpTemplateException.java
@@ -0,0 +1,30 @@
+/*
+ *
+ * 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;
+
+@SuppressWarnings("serial")
+public class AmqpTemplateException extends Exception
+{
+	public AmqpTemplateException(String msg)
+	{
+		super(msg);
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpTypeMappingException.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpTypeMappingException.java
new file mode 100644
index 0000000000..1053543fdd
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpTypeMappingException.java
@@ -0,0 +1,30 @@
+/*
+ *
+ * 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;
+
+@SuppressWarnings("serial")
+public class AmqpTypeMappingException extends Exception
+{
+	public AmqpTypeMappingException(String msg)
+	{
+		super(msg);
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpVersion.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpVersion.java
new file mode 100644
index 0000000000..579d8e28b2
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpVersion.java
@@ -0,0 +1,68 @@
+/*
+ *
+ * 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;
+
+public class AmqpVersion implements Comparable<AmqpVersion>
+{
+	private int major;
+	private int minor;
+	
+	public AmqpVersion(int major, int minor)
+	{
+		this.major = major;
+		this.minor = minor;
+	}
+
+	public AmqpVersion(AmqpVersion version)
+	{
+		this.major = version.major;
+		this.minor = version.minor;
+	}
+	
+	public int getMajor()
+	{
+		return major;
+	}
+	
+	public int getMinor()
+	{
+		return minor;
+	}
+	
+	public int compareTo(AmqpVersion v)
+	{
+		if (major != v.major)
+			return major - v.major;
+		if (minor != v.minor)
+			return minor - v.minor;
+		return 0;
+	}
+	
+	public String namespace()
+	{
+		return "ver_" + major + "_" + minor;
+	}
+	
+	public String toString()
+	{
+		return major + "-" + minor;
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpVersionSet.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpVersionSet.java
new file mode 100644
index 0000000000..4406893cbb
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/AmqpVersionSet.java
@@ -0,0 +1,74 @@
+/*
+ *
+ * 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.PrintStream;
+//import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.TreeSet;
+
+@SuppressWarnings("serial")
+public class AmqpVersionSet extends TreeSet<AmqpVersion> implements Printable, Comparable<AmqpVersionSet>
+{
+    public AmqpVersionSet()
+    {
+    	super();
+    }
+    
+    public AmqpVersionSet(AmqpVersion version)
+    {
+    	super();
+        add(version);
+    }
+    
+    public AmqpVersion find(AmqpVersion version)
+    {
+    	for (AmqpVersion v : this)
+    	{
+    		if (v.compareTo(version) == 0)
+    			return v;
+    	}
+    	return null;
+    }
+    
+	public void print(PrintStream out, int marginSize, int tabSize)
+	{
+		out.print(Utils.createSpaces(marginSize) + "Version Set: " + toString() + Utils.lineSeparator);
+	}
+    
+    public int compareTo(AmqpVersionSet other)
+    {
+        int res = size() - other.size();
+        if (res != 0)
+            return res;
+        Iterator<AmqpVersion> vItr = iterator();
+        Iterator<AmqpVersion> oItr = other.iterator();
+        while (vItr.hasNext() && oItr.hasNext())
+        {
+            AmqpVersion version = vItr.next();
+            AmqpVersion oVersion = oItr.next();
+            res = version.compareTo(oVersion);
+            if (res != 0)
+                return res;
+        }
+        return 0;
+    }
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/CppGenerator.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/CppGenerator.java
new file mode 100644
index 0000000000..b46d6e8cfc
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/CppGenerator.java
@@ -0,0 +1,1635 @@
+/*
+ *
+ * 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.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+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(AmqpVersionSet versionList)
+    {
+        super(versionList);
+        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 getDomainType(String domainName, AmqpVersion version)
+        throws AmqpTypeMappingException
+    {
+        if (version == null)
+            version = globalVersionSet.first();
+        return globalDomainMap.getDomainType(domainName, version);
+    }
+        
+    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)
+    {
+        StringBuffer sb = new StringBuffer(filenameTemplate);
+        if (thisClass != null)
+            replaceToken(sb, "${CLASS}", thisClass.name);
+        if (method != null)
+            replaceToken(sb, "${METHOD}", method.name);
+        if (field != null)
+            replaceToken(sb, "${FIELD}", field.name);
+        return sb.toString();
+    }
+        
+    @Override
+        protected void processTemplateA(String[] template)
+        throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+               IllegalAccessException, InvocationTargetException
+    {
+        processTemplateD(template, null, null, null);
+    }
+        
+    @Override
+        protected void processTemplateB(String[] template, AmqpClass thisClass)
+        throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+               IllegalAccessException, InvocationTargetException
+    {
+        processTemplateD(template, thisClass, null, null);
+    }
+        
+    @Override
+        protected void processTemplateC(String[] template, AmqpClass thisClass,
+                                        AmqpMethod method)
+        throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+               IllegalAccessException, InvocationTargetException
+    {
+        StringBuffer sb = new StringBuffer(template[templateStringIndex]);
+        String filename = prepareFilename(getTemplateFileName(sb), thisClass, method, 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(globalVersionSet))
+                    {
+                        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.versionSet)
+                                    {
+                                        StringBuffer nssb = new StringBuffer(namespaceSpan);
+                                        processTemplate(nssb, thisClass, method, null, template[templateFileNameIndex], v);
+                                        sb.insert(namespaceStartIndex, nssb);                                           
+                                    }
+                                // Process all tokens *not* within the namespace span prior to inserting namespaces
+                                processTemplate(sb, thisClass, method, null, template[templateFileNameIndex], 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[templateFileNameIndex], null);
+            }
+        writeTargetFile(sb, new File(genDir + Utils.fileSeparator + filename));
+        generatedFileCounter ++;
+    }
+        
+    @Override
+        protected void processTemplateD(String[] template, AmqpClass thisClass, AmqpMethod method,
+                                        AmqpField field)
+        throws IOException, AmqpTemplateException, AmqpTypeMappingException, IllegalAccessException,
+               InvocationTargetException
+    {
+        StringBuffer sb = new StringBuffer(template[templateStringIndex]);
+        String filename = prepareFilename(getTemplateFileName(sb), thisClass, method, field);
+        processTemplate(sb, thisClass, method, field, template[templateFileNameIndex], null);           
+        writeTargetFile(sb, new File(genDir + Utils.fileSeparator + filename));
+        generatedFileCounter ++;
+    }
+        
+    protected void processTemplate(StringBuffer sb, AmqpClass thisClass, AmqpMethod method,
+                                   AmqpField field, String templateFileName, AmqpVersion version)
+        throws InvocationTargetException, IllegalAccessException, AmqpTypeMappingException
+    {
+        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)
+        throws AmqpTemplateException, AmqpTypeMappingException
+    {
+        if (token.compareTo("${GENERATOR}") == 0)
+            return generatorInfo;
+        if (token.compareTo("${CLASS}") == 0 && thisClass != null)
+            return thisClass.name;
+        if (token.compareTo("${CLASS_ID_INIT}") == 0 && thisClass != null)
+            {
+                if (version == null)
+                    return String.valueOf(thisClass.indexMap.firstKey());
+                return getIndex(thisClass.indexMap, version);
+            }
+        if (token.compareTo("${METHOD}") == 0 && method != null)
+            return method.name;
+        if (token.compareTo("${METHOD_ID_INIT}") == 0 && method != null)
+            {
+                if (version == null)
+                    return String.valueOf(method.indexMap.firstKey());
+                return getIndex(method.indexMap, version);
+            }
+        if (token.compareTo("${FIELD}") == 0 && field != null)
+            return field.name;
+        if (token.equals(versionNamespaceStartToken) && version != null)
+            return "namespace " + version.namespace() + cr + "{";
+        if (token.equals(versionNamespaceEndToken) && version != null)
+            return "} // namespace " + version.namespace();
+        if (token.equals("${mb_constructor_with_initializers}"))
+            return generateConstructor(thisClass, method, version, 4, 4);
+        if (token.equals("${mb_server_operation_invoke}"))
+            return generateServerOperationsInvoke(thisClass, method, version, 4, 4);
+        if (token.equals("${mb_buffer_param}"))
+            return method.fieldMap.size() > 0 ? " buffer" : "/*buffer*/";
+        if (token.equals("${hv_latest_major}"))
+            return String.valueOf(globalVersionSet.last().getMajor());
+        if (token.equals("${hv_latest_minor}"))
+            return String.valueOf(globalVersionSet.last().getMinor());
+	if (token.equals("${mb_base_class}")) 
+	    return baseClass(method, version);
+            
+        throw new AmqpTemplateException("Template token " + token + " unknown.");       
+    }
+
+    private String baseClass(AmqpMethod method, AmqpVersion version) {
+	String base = method.isResponse(version) ? "AMQResponseBody":"AMQRequestBody";
+	return base;
+    }
+    
+    @Override
+        protected void processClassList(StringBuffer sb, int listMarkerStartIndex, int listMarkerEndIndex,
+                                        AmqpModel model)
+        throws AmqpTemplateException, AmqpTypeMappingException
+    {
+        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 = generateProxyInnerClassDeclarations(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 = generateProxyInnerClassDeclarations(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)
+        throws AmqpTemplateException, AmqpTypeMappingException
+    {
+        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)
+        throws AmqpTypeMappingException, AmqpTemplateException, IllegalAccessException,
+               InvocationTargetException
+    {
+        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.equals("${mb_field_declaration}") )
+	    codeSnippet = generateFieldDeclarations(fieldMap, version, 4);
+        else if (token.equals("${mb_field_get_method}") )
+	    codeSnippet = generateFieldGetMethods(fieldMap, version, 4);
+        else if (token.equals("${mb_field_print}") )
+	    codeSnippet = generatePrintMethodContents(fieldMap, version, 8);
+        else if (token.equals("${mb_body_size}") )
+	    codeSnippet = generateBodySizeMethodContents(fieldMap, version, 8);
+        else if (token.equals("${mb_encode}") )
+	    codeSnippet = generateEncodeMethodContents(fieldMap, version, 8);
+        else if (token.equals("${mb_decode}") )
+	    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)
+        throws AmqpTemplateException, AmqpTypeMappingException
+    {
+        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)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+        for (AmqpConstant thisConstant : constantSet)
+            {
+                if (thisConstant.isVersionConsistent(globalVersionSet))
+                    {
+                        // return a constant
+                        String value = thisConstant.firstKey();
+                        sb.append(indent + "static const char* " + thisConstant.name + "() { return \"" +
+                                  thisConstant.firstKey() + "\"; }" + cr);
+                        if (Utils.containsOnlyDigits(value))
+                            {
+                                sb.append(indent + "static int " + thisConstant.name + "AsInt() { return " +
+                                          thisConstant.firstKey() + "; }" + cr);
+                            }
+                        if (Utils.containsOnlyDigitsAndDecimal(value))
+                            {
+                                sb.append(indent + "static double " + thisConstant.name + "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)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        String tab = Utils.createSpaces(tabSize);
+        StringBuffer sb = new StringBuffer();
+        sb.append(indent + methodReturnType + " " + constant.name + 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.name, methodReturnType,
+                                                                       indentSize + (2*tabSize), tabSize));
+                    }
+                else if (methodReturnType.compareTo("double") == 0 && !Utils.containsOnlyDigitsAndDecimal(thisValue))
+                    {
+                        sb.append(generateConstantDeclarationException(constant.name, 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.name +
+                  "\\\" 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.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.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.methodMap.keySet())
+                    {
+                        AmqpMethod method = thisClass.methodMap.get(thisMethodName);
+                        boolean clientChassisFlag = method.clientMethodFlagMap.isSet();
+                        boolean serverChassisFlag = method.serverMethodFlagMap.isSet();
+                        if ((serverFlag && serverChassisFlag) || (!serverFlag && clientChassisFlag))
+                            chassisFoundFlag = true;
+                    }
+                if (chassisFoundFlag)
+                    {
+                        sb.append(indent + "virtual AMQP_" + (serverFlag ? "Server" : "Client") + "Operations::" +
+                                  thisClass.name + "Handler* get" + thisClass.name + "Handler() = 0;" + cr);
+                    }
+            }
+        return sb.toString();
+    }
+        
+    protected String generateOpsInnerClasses(AmqpModel model, boolean serverFlag, int indentSize, int tabSize)
+        throws AmqpTypeMappingException
+    {
+                
+        String indent = Utils.createSpaces(indentSize);
+        String tab = Utils.createSpaces(tabSize);
+        StringBuffer sb = new StringBuffer();
+        boolean first = true;
+        for (String thisClassName : model.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.get(thisClassName);
+                String handlerClassName = thisClass.name + "Handler";
+                if (!first)
+                    sb.append(cr);
+                sb.append(indent + "// ==================== class " + handlerClassName +
+                          " ====================" + cr);
+                sb.append(indent + "class " + handlerClassName);
+                if (thisClass.versionSet.size() != globalVersionSet.size())
+                    sb.append(" // AMQP Version(s) " + thisClass.versionSet + cr);
+                else
+                    sb.append(cr);
+                sb.append(indent + "{" + cr);
+                sb.append(indent + tab + "// Constructors and destructors" + cr);
+                sb.append(indent + "public:" + cr);
+                sb.append(indent + tab + handlerClassName + "(){};\n");
+                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)
+        throws AmqpTypeMappingException
+    {
+        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.methodMap.keySet())
+            {
+                AmqpMethod method = thisClass.methodMap.get(thisMethodName);
+                String returnType = (abstractMethodFlag || method.isResponse(null))? "void" : "RequestId";
+                boolean clientChassisFlag = method.clientMethodFlagMap.isSet();
+                boolean serverChassisFlag = method.serverMethodFlagMap.isSet();
+                if ((serverFlag && serverChassisFlag) || (!serverFlag && clientChassisFlag))
+                    {
+                        String methodName = parseForReservedWords(method.name, outerClassName + "." + thisClass.name);                          
+                        AmqpOverloadedParameterMap overloadededParameterMap =
+                            method.getOverloadedParameterLists(thisClass.versionSet, this);
+                        for (AmqpOrdinalFieldMap thisFieldMap : overloadededParameterMap.keySet())
+                            {
+                                AmqpVersionSet versionSet = overloadededParameterMap.get(thisFieldMap);
+                                if (!first) sb.append(cr);
+                                sb.append(indent + "virtual "+returnType+" "+ methodName + "(");
+                                if (abstractMethodFlag) sb.append("const MethodContext& context");
+                                boolean leadingComma = abstractMethodFlag;
+                                int paramIndent = indentSize + (5*tabSize);
+								sb.append(generateMethodParameterList(thisFieldMap, paramIndent, leadingComma, true, true));
+                                if (!abstractMethodFlag && method.isResponse(null)) {
+                                	if (!thisFieldMap.isEmpty()) sb.append(", \n"+Utils.createSpaces(paramIndent));
+                                	sb.append("	RequestId responseTo");
+                                }
+                                sb.append(" )");
+                                if (abstractMethodFlag)
+                                    sb.append(" = 0");
+                                sb.append(";");
+                                if (versionSet.size() != globalVersionSet.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.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.get(thisClassName);
+                sb.append(indent + outerClassName + "::" + thisClass.name + "Handler* " +
+                          thisClass.name + "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.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.get(thisClassName);
+                sb.append(indent + "virtual " + outerClassName + "::" + thisClass.name + "Handler* get" +
+                          thisClass.name + "Handler() { return &" + Utils.firstLower(thisClass.name) + ";}" + cr);
+            }
+        return sb.toString();
+    }
+        
+    public String proxyInstanceName(AmqpClass inner,  String outer) {
+	return parseForReservedWords(Utils.firstLower(inner.name), outer)
+	    + "Proxy";
+    }
+
+    protected String generateProxyInnerClassInstances(AmqpModel model, boolean serverFlag,
+                                                      int indentSize)
+    {
+        String indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+        String outerClassName = proxyOuterClassName(serverFlag);
+        for (String thisClassName : model.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.get(thisClassName);
+                String className = parseForReservedWords(thisClass.name, null);
+                sb.append(indent + className + " " +
+			  proxyInstanceName(thisClass, outerClassName) + ";");
+                if (thisClass.versionSet.size() != globalVersionSet.size())
+                    sb.append(" // AMQP Version(s) " + thisClass.versionSet + 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();
+        for (String thisClassName : model.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.get(thisClassName);
+                String className = parseForReservedWords(thisClass.name, proxyOuterClassName(serverFlag));
+                sb.append(indent + className + "& get" + className + "();");
+                if (thisClass.versionSet.size() != globalVersionSet.size())
+                    sb.append(" // AMQP Version(s) " + thisClass.versionSet + cr);
+                else
+                    sb.append(cr);
+            }
+        return sb.toString();
+    }
+
+	private String proxyOuterClassName(boolean serverFlag) {
+		return "AMQP_" + (serverFlag ? "Server" : "Client") + "Proxy";
+	}
+        
+    protected String generateProxyInnerClassDeclarations(AmqpModel model, boolean serverFlag,
+                                                        int indentSize, int tabSize)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        String tab = Utils.createSpaces(tabSize);
+        StringBuffer sb = new StringBuffer();
+        boolean first = true;
+        for (String thisClassName : model.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.get(thisClassName);
+                String className = thisClass.name;
+                if (!first)
+                    sb.append(cr);
+                sb.append(indent + "// ==================== class " + className +
+                          " ====================" + cr);
+                sb.append(indent + "class " + className);
+                if (thisClass.versionSet.size() != globalVersionSet.size())
+                    sb.append(" // AMQP Version(s) " + thisClass.versionSet + cr);
+                else
+                    sb.append(cr);
+                sb.append(indent + "{" + cr);
+                sb.append(indent + "private:" + cr);
+                sb.append(indent + tab + "ChannelAdapter& channel;" + 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 + "(ChannelAdapter& ch) : " + cr);
+                sb.append(indent + tab + tab + "channel(ch) {}" + cr);
+                sb.append(indent + tab + "virtual ~" + className + "() {}" + cr);
+                sb.append(cr);
+                sb.append(indent + tab + "static "+className+"& get(" + proxyOuterClassName(serverFlag)+"& proxy) { return proxy.get"+className+"();}\n\n");
+                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 indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+        Iterator<String> cItr = model.classMap.keySet().iterator();
+        while (cItr.hasNext())
+            {
+                AmqpClass thisClass = model.classMap.get(cItr.next());
+                sb.append(",\n");
+                sb.append(indent + proxyInstanceName(thisClass, proxyOuterClassName(serverFlag))
+			  + "(channel)");
+            }
+	sb.append("\n");
+        return sb.toString();   
+    }
+        
+    protected String generateProxyInnerClassGetMethodImpls(AmqpModel model, boolean serverFlag,
+                                                           int indentSize, int tabSize)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        String tab = Utils.createSpaces(tabSize);
+        StringBuffer sb = new StringBuffer();
+        String outerClassName = proxyOuterClassName(serverFlag);
+        Iterator<String> cItr = model.classMap.keySet().iterator();
+        while (cItr.hasNext())
+            {
+                AmqpClass thisClass = model.classMap.get(cItr.next());
+                String className = thisClass.name;
+                sb.append(indent + outerClassName + "::" + className + "& " +
+                          outerClassName + "::get" + className + "()" + cr);
+                sb.append(indent + "{" + cr);
+                if (thisClass.versionSet.size() != globalVersionSet.size())
+                    {
+                        sb.append(indent + tab + "if (!" + generateVersionCheck(thisClass.versionSet) + ")" + cr);
+                        sb.append(indent + tab + tab + "throw new ProtocolVersionException();" + cr);
+                    }
+                sb.append(indent + tab + "return " +
+			  proxyInstanceName(thisClass, outerClassName) + ";" + 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)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+        boolean firstClassFlag = true;
+        for (String thisClassName : model.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.get(thisClassName);
+                String className = thisClass.name;
+                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)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+        String outerclassName = proxyOuterClassName(serverFlag);
+        boolean first = true;
+        for (String thisMethodName : thisClass.methodMap.keySet())
+            {
+                AmqpMethod method = thisClass.methodMap.get(thisMethodName);
+                String methodBodyClassName = thisClass.name + Utils.firstUpper(method.name) + "Body";
+                boolean clientChassisFlag = method.clientMethodFlagMap.isSet();
+                boolean serverChassisFlag = method.serverMethodFlagMap.isSet();
+                boolean versionConsistentFlag = method.isVersionConsistent(globalVersionSet);
+                if ((serverFlag && serverChassisFlag) || (!serverFlag && clientChassisFlag))
+                    {
+                        String methodName = parseForReservedWords(method.name, outerclassName + "." + thisClass.name);
+                        AmqpOverloadedParameterMap overloadededParameterMap =
+                            method.getOverloadedParameterLists(thisClass.versionSet, this);
+                        for (AmqpOrdinalFieldMap thisFieldMap : overloadededParameterMap.keySet())
+                            {
+                                AmqpVersionSet versionSet = overloadededParameterMap.get(thisFieldMap);
+                                if (!first)
+                                    sb.append(cr);
+                                String returnType =  method.isResponse(null) ? "void" : "RequestId";
+                                sb.append(indent + returnType + " " + outerclassName + "::" + thisClass.name + "::" +
+                                          methodName + "(");
+                                sb.append(generateMethodParameterList(thisFieldMap, indentSize + (5*tabSize), false, true, true));
+                                if (method.isResponse(null)) {
+                                    if (!thisFieldMap.isEmpty()) sb.append(", ");
+                                	sb.append("RequestId responseTo");
+                                }
+                                sb.append(")");
+                                if (versionSet.size() != globalVersionSet.size())
+                                    sb.append(" // AMQP Version(s) " + versionSet);
+                                sb.append(cr);
+                                sb.append(indent + "{" + cr);
+                                sb.append(generateMethodBodyCallContext(method, thisFieldMap, outerclassName, methodBodyClassName,
+                                                                        versionConsistentFlag, versionSet, indentSize + tabSize, tabSize));
+                                sb.append(indent + "}" + cr);
+                                sb.append(cr);
+                                first = false;
+                            }
+                    }
+            }
+        return sb.toString();           
+    }
+        
+    protected String generateMethodBodyCallContext(AmqpMethod method, AmqpOrdinalFieldMap fieldMap, String outerclassName,
+                                                   String methodBodyClassName, boolean versionConsistentFlag, AmqpVersionSet versionSet,
+                                                   int indentSize, int tabSize)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        String tab = Utils.createSpaces(tabSize);
+        StringBuffer sb = new StringBuffer();
+        if (versionConsistentFlag)
+            {
+                sb.append(generateProxyMethodBody(method, 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(generateProxyMethodBody(method, 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 generateProxyMethodBody(AmqpMethod method, AmqpOrdinalFieldMap fieldMap, String methodBodyClassName,
+                                            AmqpVersion version, int indentSize, int tabSize)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        String tab = Utils.createSpaces(tabSize);
+        String namespace = version != null ? version.namespace() + "::" : "";
+        StringBuffer sb = new StringBuffer();
+        sb.append(indent+tab+(method.isResponse(version) ? "" : "return ")+"channel.send(new ");
+        sb.append(namespace + methodBodyClassName + "( channel.getVersion()");
+        if (method.isResponse(version)) sb.append(", responseTo");
+        sb.append(generateMethodParameterList(fieldMap, indentSize + (5*tabSize), true, false, true));
+        sb.append("));\n");
+        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 : model.classMap.keySet())
+                    {
+                        thisClass = model.classMap.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.methodMap.keySet())
+            {
+                AmqpMethod method = thisClass.methodMap.get(thisMethodName);
+                sb.append(indent + "#include <" + thisClass.name +
+                          Utils.firstUpper(method.name) + "Body.h>" + cr);
+            }
+        return sb.toString();       
+    }
+    
+    // Methods used for generation of code snippets for MethodBody class generation
+
+    protected String getIndex(AmqpOrdinalVersionMap indexMap, AmqpVersion version)
+        throws AmqpTemplateException
+    {
+        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)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+        
+        if (version == null)
+            version = globalVersionSet.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)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+                
+        if (version == null)
+            version = globalVersionSet.first();
+        AmqpOrdinalFieldMap ordinalFieldMap = fieldMap.getMapForVersion(version, true, this);
+        for (Integer thisOrdinal : ordinalFieldMap.keySet())
+            {
+                String[] fieldDomainPair = ordinalFieldMap.get(thisOrdinal);
+                sb.append(indent + "" + 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)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+                
+        if (version == null)
+            version = globalVersionSet.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)
+        throws AmqpTypeMappingException
+    {
+        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 ? globalVersionSet.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 + "sz += " +
+                                  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 + "sz += " +
+                  typeMap.get("bit").size.replaceAll("~", String.valueOf(numBytes)) +
+                  "; /* " + comment + " */" + cr);
+        bitFieldList.clear();           
+        return sb.toString();                           
+    }
+        
+    protected String generateEncodeMethodContents(AmqpFieldMap fieldMap, AmqpVersion version,
+                                                  int indentSize)
+        throws AmqpTypeMappingException
+    {
+        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 ? globalVersionSet.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)
+        throws AmqpTypeMappingException
+    {
+        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 ? globalVersionSet.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)
+        throws AmqpTypeMappingException
+    {
+        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)
+        throws AmqpTypeMappingException
+    {
+        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)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        String tab = Utils.createSpaces(tabSize);
+        StringBuffer sb = new StringBuffer();
+        if (method.fieldMap.size() > 0 || method.isResponse(version))
+            {
+                sb.append(indent + thisClass.name + Utils.firstUpper(method.name) + "Body(ProtocolVersion version," + cr);
+		if (method.isResponse(version)) {
+		    sb.append(indent+tab+"RequestId toRequest");
+		    if (method.fieldMap.size() >0) 
+			sb.append(",\n");
+		}
+		sb.append(generateFieldList(method.fieldMap, version, true, false, 8));
+                sb.append(indent + tab + ") : " + baseClass(method, version) + "(version");
+		if (method.isResponse(version))
+		    sb.append(", 0, toRequest");
+		sb.append(")");
+		if (method.fieldMap.size() > 0) 
+		    sb.append(", \n" + generateFieldList(method.fieldMap, version, false, true, 8));
+                sb.append(indent + "{ }\n");
+            }
+        return sb.toString();         
+    }
+    
+    protected String generateServerOperationsInvoke(AmqpClass thisClass, AmqpMethod method,
+                                                    AmqpVersion version, int indentSize, int tabSize)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        String tab = Utils.createSpaces(tabSize);
+        StringBuffer sb = new StringBuffer();
+        
+        if (method.serverMethodFlagMap.size() > 0) // At least one AMQP version defines this method as a server method
+            {
+                Iterator<Boolean> bItr = method.serverMethodFlagMap.keySet().iterator();
+                while (bItr.hasNext())
+                    {
+                        if (bItr.next()) // This is a server operation
+                            {
+                                boolean fieldMapNotEmptyFlag = method.fieldMap.size() > 0;
+                                sb.append(indent + "void invoke(AMQP_ServerOperations& target, const MethodContext& context)" + cr);
+                                sb.append(indent + "{" + cr);
+                                sb.append(indent + tab + "target.get" + thisClass.name + "Handler()->" +
+                                          parseForReservedWords(Utils.firstLower(method.name),
+                                                                thisClass.name + Utils.firstUpper(method.name) + "Body.invoke()") + "(context");
+                                if (fieldMapNotEmptyFlag)
+                                    {
+                                        sb.append("," + cr);
+                                        sb.append(generateFieldList(method.fieldMap, 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.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.get(thisClassName);
+                for (String thisMethodName : thisClass.methodMap.keySet())
+                    {
+                        AmqpMethod method = thisClass.methodMap.get(thisMethodName);
+                        sb.append(indent + "#include \"" + thisClass.name + Utils.firstUpper(method.name) + "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.classMap.keySet())
+            {
+                AmqpClass thisClass = model.classMap.get(thisClassName);
+                for (String thisMethodName : thisClass.methodMap.keySet())
+                    {
+                        AmqpMethod method = thisClass.methodMap.get(thisMethodName);
+                        sb.append(indent + "const " + thisClass.name + Utils.firstUpper(method.name) + "Body " +
+                                  Utils.firstLower(thisClass.name) + "_" + method.name + ";" + cr);
+                    }
+            }
+       
+        return sb.toString();       
+    }
+    
+    protected String generateMethodBodyMapEntry(AmqpModel model, int indentSize)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+        
+        for (AmqpVersion version : globalVersionSet)
+            {
+                for (String thisClassName : model.classMap.keySet())
+                    {
+                        AmqpClass thisClass = model.classMap.get(thisClassName);
+                        for (String thisMethodName : thisClass.methodMap.keySet())
+                            {
+                                AmqpMethod method = thisClass.methodMap.get(thisMethodName);
+                                String namespace = method.isVersionConsistent(globalVersionSet) ? "" : version.namespace() + "::";
+                                try
+                                    {
+                                        int classOrdinal = thisClass.indexMap.getOrdinal(version);
+                                        int methodOrdinal = method.indexMap.getOrdinal(version);
+                                        String methodModyClassName = namespace + thisClass.name + Utils.firstUpper(method.name) + "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)
+        throws AmqpTypeMappingException
+    {
+        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.equals("string")  ||
+            codeType.equals("FieldTable") ||
+            codeType.equals("Content"))
+            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();
+    }
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/DotnetGenerator.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/DotnetGenerator.java
new file mode 100644
index 0000000000..505a70dc85
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/DotnetGenerator.java
@@ -0,0 +1,339 @@
+/*
+ *
+ * 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.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.util.TreeMap;
+
+public class DotnetGenerator extends Generator
+{
+	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 DotnetGenerator(AmqpVersionSet versionList)
+	{
+		super(versionList);
+		// Load .NET 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).
+		// TODO: I have left a copy of the Java typeMap here - replace with appropriate .NET values.
+		typeMap.put("bit", new DomainInfo(
+			"boolean",										// .NET code type
+			"~",											// size
+			"EncodingUtils.writeBooleans(buffer, #)",		// encode expression
+			"# = EncodingUtils.readBooleans(buffer)"));		// decode expression
+		typeMap.put("content", new DomainInfo(
+			"Content",										// .NET code type
+			"EncodingUtils.encodedContentLength(#)", 	// size
+			"EncodingUtils.writeContentBytes(buffer, #)", // encode expression
+			"# = EncodingUtils.readContent(buffer)"));	// decode expression
+		typeMap.put("long", new DomainInfo(
+			"long",											// .NET code type
+			"4",											// size
+			"EncodingUtils.writeUnsignedInteger(buffer, #)", // encode expression
+			"# = buffer.getUnsignedInt()")); 				// decode expression
+		typeMap.put("longlong", new DomainInfo(
+			"long",											// .NET code type
+			"8",											// size
+			"buffer.putLong(#)", 							// encode expression
+			"# = buffer.getLong()")); 						// decode expression
+		typeMap.put("longstr", new DomainInfo(
+			"byte[]",										// .NET code type
+			"EncodingUtils.encodedLongstrLength(#)", 		// size
+			"EncodingUtils.writeLongStringBytes(buffer, #)", // encode expression
+			"# = EncodingUtils.readLongstr(buffer)"));		// decode expression
+		typeMap.put("octet", new DomainInfo(
+			"short",										// .NET code type
+			"1",											// size
+			"EncodingUtils.writeUnsignedByte(buffer, #)",	// encode expression
+			"# = buffer.getUnsigned()")); 					// decode expression
+		typeMap.put("short", new DomainInfo(
+			"int",											// .NET code type
+			"2",											// size
+			"EncodingUtils.writeUnsignedShort(buffer, #)",	// encode expression
+			"# = buffer.getUnsignedShort()")); 				// decode expression
+		typeMap.put("shortstr", new DomainInfo(
+			"AMQShortString",								// .NET code type
+			"EncodingUtils.encodedShortStringLength(#)",	// size
+			"EncodingUtils.writeShortStringBytes(buffer, #)", // encode expression
+			"# = EncodingUtils.readAMQShortString(buffer)"));	// decode expression
+		typeMap.put("table", new DomainInfo(
+			"FieldTable",									// .NET code type
+			"EncodingUtils.encodedFieldTableLength(#)", 	// size
+			"EncodingUtils.writeFieldTableBytes(buffer, #)", // encode expression
+			"# = EncodingUtils.readFieldTable(buffer)"));	// decode expression
+		typeMap.put("timestamp", new DomainInfo(
+			"long",											// .NET code type
+			"8",											// size
+			"EncodingUtils.writeTimestamp(buffer, #)",		// encode expression
+			"# = EncodingUtils.readTimestamp(buffer)"));	// decode expression
+	}
+
+	@Override
+	protected String prepareFilename(String filenameTemplate,
+			AmqpClass thisClass, AmqpMethod method, AmqpField field)
+	{
+		StringBuffer sb = new StringBuffer(filenameTemplate);
+		if (thisClass != null)
+			replaceToken(sb, "${CLASS}", thisClass.name);
+		if (method != null)
+			replaceToken(sb, "${METHOD}", method.name);
+		if (field != null)
+			replaceToken(sb, "${FIELD}", field.name);
+		return sb.toString();
+	}
+
+	@Override
+	protected void processClassList(StringBuffer sb, int listMarkerStartIndex,
+			int listMarkerEndIndex, AmqpModel model)
+			throws AmqpTemplateException, AmqpTypeMappingException
+	{
+		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: Add in tokens and calls to their corresponding generator methods here...
+		if (token.compareTo("${??????????}") == 0)
+		{
+			codeSnippet = token; // This is a stub to get the compile working - remove when gen method is present.
+//			codeSnippet = generateRegistry(model, 8, 4); 
+		}
+		
+		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) throws AmqpTemplateException,
+			AmqpTypeMappingException
+	{
+        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: Add in tokens and calls to their corresponding generator methods here...
+        if (token.compareTo("${??????????}") == 0)
+        {
+			codeSnippet = token; // This is a stub to get the compile working - remove when gen method is present.
+//            codeSnippet = generateConstantGetMethods(constantSet, 4, 4); 
+        }
+       
+        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)
+			throws AmqpTypeMappingException, AmqpTemplateException,
+			IllegalAccessException, InvocationTargetException
+	{
+		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: Add in tokens and calls to their corresponding generator methods here...
+		if (token.compareTo("${??????????}") == 0)
+		{
+			codeSnippet = token; // This is a stub to get the compile working - remove when gen method is present.
+//			codeSnippet = fieldMap.parseFieldMap(declarationGenerateMethod,
+//				mangledDeclarationGenerateMethod, 4, 4, this);
+		}
+		
+		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)
+			throws AmqpTemplateException, AmqpTypeMappingException
+	{
+		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: Add in tokens and calls to their corresponding generator methods here...
+		if (token.compareTo("${??????????}") == 0)
+		{
+			codeSnippet = token; // This is a stub to get the compile working - remove when gen method is present.
+		}
+		
+		else // Oops!
+		{
+			throw new AmqpTemplateException("Template token " + token + " unknown.");
+		}
+		sb.insert(listMarkerStartIndex, codeSnippet);
+	}
+
+	@Override
+	protected void processTemplateA(String[] template) throws IOException,
+			AmqpTemplateException, AmqpTypeMappingException,
+			IllegalAccessException, InvocationTargetException
+	{
+		// I've put in the Java model here - this can be changed if a different pattern is required.
+		processTemplateD(template, null, null, null);
+	}
+
+	@Override
+	protected void processTemplateB(String[] template, AmqpClass thisClass)
+			throws IOException, AmqpTemplateException,
+			AmqpTypeMappingException, IllegalAccessException,
+			InvocationTargetException
+	{
+		// I've put in the Java model here - this can be changed if a different pattern is required.
+		processTemplateD(template, thisClass, null, null);
+	}
+
+	@Override
+	protected void processTemplateC(String[] template, AmqpClass thisClass,
+			AmqpMethod method) throws IOException, AmqpTemplateException,
+			AmqpTypeMappingException, IllegalAccessException,
+			InvocationTargetException
+	{
+		// I've put in the Java model here - this can be changed if a different pattern is required.
+		processTemplateD(template, thisClass, method, null);
+	}
+
+	@Override
+	protected void processTemplateD(String[] template, AmqpClass thisClass,
+			AmqpMethod method, AmqpField field) throws IOException,
+			AmqpTemplateException, AmqpTypeMappingException,
+			IllegalAccessException, InvocationTargetException
+	{
+		// I've put in the Java model here - this can be changed if a different pattern is required.
+		StringBuffer sb = new StringBuffer(template[1]);
+		String filename = prepareFilename(getTemplateFileName(sb), thisClass, method, field);
+		try { processAllLists(sb, thisClass, method, null); }
+		catch (AmqpTemplateException e)
+		{
+			System.out.println("WARNING: " + template[templateFileNameIndex] + ": " + e.getMessage());
+		}
+		try { processAllTokens(sb, thisClass, method, field, null); }
+		catch (AmqpTemplateException e)
+		{
+			System.out.println("WARNING: " + template[templateFileNameIndex] + ": " + e.getMessage());
+		}
+		writeTargetFile(sb, new File(genDir + Utils.fileSeparator + filename));
+		generatedFileCounter ++;
+	}
+
+	@Override
+	protected String processToken(String token, AmqpClass thisClass,
+			AmqpMethod method, AmqpField field, AmqpVersion version)
+			throws AmqpTemplateException, AmqpTypeMappingException
+	{
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public String getDomainType(String domainName, AmqpVersion version)
+			throws AmqpTypeMappingException
+	{
+		return globalDomainMap.getDomainType(domainName, version);
+	}
+
+	public String getGeneratedType(String domainName, AmqpVersion version)
+			throws AmqpTypeMappingException
+	{
+		String domainType = globalDomainMap.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;
+	}
+
+	public String prepareClassName(String className)
+	{
+		return camelCaseName(className, true);
+	}
+
+	public String prepareDomainName(String domainName)
+	{
+		return camelCaseName(domainName, false);
+	}
+
+	public String prepareMethodName(String methodName)
+	{
+		return camelCaseName(methodName, false);
+	}
+
+	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();
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/Generator.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/Generator.java
new file mode 100644
index 0000000000..e7ccd64fbe
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/Generator.java
@@ -0,0 +1,429 @@
+/*
+ *
+ * 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.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.LineNumberReader;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+
+public abstract class Generator implements LanguageConverter
+{
+    protected static String cr = Utils.lineSeparator;
+    protected static enum EnumConstOutputTypes { OUTPUT_STRING, OUTPUT_INTEGER, OUTPUT_DOUBLE; };
+    
+	// This string is reproduced in every generated file as a comment
+	// TODO: Tie the version info into the build system.
+	protected static final String generatorInfo = "Qpid Gentools v.0.1";
+	protected static final int templateFileNameIndex = 0;
+	protected static final int templateStringIndex = 1;
+	
+	protected ArrayList<String[]> modelTemplateList;
+	protected ArrayList<String[]> classTemplateList;
+	protected ArrayList<String[]> methodTemplateList;
+	protected ArrayList<String[]> fieldTemplateList;
+	protected String genDir;
+	
+	protected AmqpVersionSet globalVersionSet;
+	protected AmqpDomainMap globalDomainMap;
+    protected AmqpConstantSet globalConstantSet;
+	protected AmqpModel model;
+	
+	protected int generatedFileCounter;
+	
+	public Generator(AmqpVersionSet versionList)
+	{
+		this.globalVersionSet = versionList;
+		modelTemplateList = new ArrayList<String[]>();
+		classTemplateList = new ArrayList<String[]>();
+		methodTemplateList = new ArrayList<String[]>();
+		fieldTemplateList = new ArrayList<String[]>();
+		generatedFileCounter = 0;	
+	}
+	
+	public int getNumberGeneratedFiles()
+	{
+		return generatedFileCounter;
+	}
+	
+	public void setDomainMap(AmqpDomainMap domainMap)
+	{
+		this.globalDomainMap = domainMap;
+	}
+	
+	public AmqpDomainMap getDomainMap()
+	{
+		return globalDomainMap;
+	}
+    
+    public void setConstantSet(AmqpConstantSet constantSet)
+    {
+        this.globalConstantSet = constantSet;
+    }
+    
+    public AmqpConstantSet getConstantSet()
+    {
+        return globalConstantSet;
+    }
+	
+	public void setModel(AmqpModel model)
+	{
+		this.model = model;
+	}
+	
+	public AmqpModel getModel()
+	{
+		return model;
+	}
+	
+	public void initializeTemplates(File[] modelTemplateFiles, File[] classTemplatesFiles,
+		File[] methodTemplatesFiles, File[] fieldTemplatesFiles)
+	    throws FileNotFoundException, IOException
+	{
+		if (modelTemplateFiles.length > 0)
+		{
+			System.out.println("Model template file(s):");
+			for (File mtf : modelTemplateFiles)
+			{
+				System.out.println("  " + mtf.getAbsolutePath());
+				String template[] = {mtf.getName(), loadTemplate(mtf)};
+				modelTemplateList.add(template);
+			}
+		}
+		if (classTemplatesFiles.length > 0)
+		{
+			System.out.println("Class template file(s):");
+			//for (int c=0; c<classTemplatesFiles.length; c++)
+			for (File ctf : classTemplatesFiles)
+			{
+				System.out.println("  " + ctf.getAbsolutePath());
+				String template[] = {ctf.getName(), loadTemplate(ctf)};
+				classTemplateList.add(template);
+			}
+		}
+		if (methodTemplatesFiles.length > 0)
+		{
+			System.out.println("Method template file(s):");
+			for (File mtf : methodTemplatesFiles)
+			{
+				System.out.println("  " + mtf.getAbsolutePath());
+				String template[] = {mtf.getName(), loadTemplate(mtf)};
+				methodTemplateList.add(template);
+			}
+		}
+		if (fieldTemplatesFiles.length > 0)
+		{
+			System.out.println("Field template file(s):");
+			for (File ftf : fieldTemplatesFiles)
+			{
+				System.out.println("  " + ftf.getAbsolutePath());
+				String template[] = {ftf.getName(), loadTemplate(ftf)};
+				fieldTemplateList.add(template);
+			}
+		}
+	}
+
+	abstract protected String prepareFilename(String filenameTemplate, AmqpClass thisClass, AmqpMethod method,
+		AmqpField field);
+
+	abstract protected String processToken(String token, AmqpClass thisClass, AmqpMethod method,
+		AmqpField field, AmqpVersion version)
+	    throws AmqpTemplateException, AmqpTypeMappingException;
+	
+	abstract protected void processClassList(StringBuffer sb, int listMarkerStartIndex, int listMarkerEndIndex,
+        AmqpModel model)
+        throws AmqpTemplateException, AmqpTypeMappingException;
+	
+	abstract protected void processMethodList(StringBuffer sb, int listMarkerStartIndex, int listMarkerEndIndex,
+        AmqpClass thisClass)
+        throws AmqpTemplateException, AmqpTypeMappingException;
+	
+	abstract protected void processFieldList(StringBuffer sb, int listMarkerStartIndex, int listMarkerEndIndex,
+		AmqpFieldMap fieldMap, AmqpVersion version)
+        throws AmqpTypeMappingException, AmqpTemplateException, IllegalAccessException,
+        	InvocationTargetException;
+    
+    abstract protected void processConstantList(StringBuffer sb, int listMarkerStartIndex, int listMarkerEndIndex,
+        AmqpConstantSet constantSet)
+        throws AmqpTemplateException, AmqpTypeMappingException;
+	
+	public void generate(File genDir)
+	    throws TargetDirectoryException, IOException, AmqpTypeMappingException,
+	    	AmqpTemplateException, IllegalAccessException, InvocationTargetException
+	{
+		prepareTargetDirectory(genDir, true);
+		System.out.println("Generation directory: " + genDir.getAbsolutePath());
+		this.genDir = genDir.getAbsolutePath();
+
+		// Use all model-level templates
+		for (String[] mt : modelTemplateList)
+		{
+			processTemplateA(mt);
+		}
+		
+		// Cycle through classes
+		for (String className : model.classMap.keySet())
+		{
+			AmqpClass thisClass = model.classMap.get(className);
+			// Use all class-level templates
+			for (String[] ct : classTemplateList)
+			{
+				processTemplateB(ct, thisClass);
+			}
+
+			// Cycle through all methods
+			for (String methodName : thisClass.methodMap.keySet())
+			{
+				AmqpMethod method = thisClass.methodMap.get(methodName);
+				// Use all method-level templates
+				for (String[] mt : methodTemplateList)
+				{
+					processTemplateC(mt, thisClass, method);
+				}
+
+				// Cycle through all fields
+				for (String fieldName : method.fieldMap.keySet())
+				{
+					AmqpField field = method.fieldMap.get(fieldName);
+					// Use all field-level templates
+					for (String[] ft : fieldTemplateList)
+					{
+						processTemplateD(ft, thisClass, method, field);
+					}
+				}
+			}
+		}
+	}
+	
+	protected void processVersionList(StringBuffer sb, int tokStart, int tokEnd)
+	    throws AmqpTypeMappingException
+	{
+		int lend = sb.indexOf(Utils.lineSeparator, tokStart) + 1; // Include cr at end of line
+		String tline = sb.substring(tokEnd, lend); // Line excluding line marker, including cr
+		sb.delete(tokStart, lend);
+		
+		for (AmqpVersion v : globalVersionSet)
+		{
+			// Insert copy of target line
+			StringBuffer isb = new StringBuffer(tline);
+			if (isb.indexOf("${protocol-version-list-entry}") >= 0)
+			{
+				String versionListEntry = "       { ${major}, ${minor} }" +
+				  (v.equals(globalVersionSet.last()) ? "" : ",");
+				replaceToken(isb, "${protocol-version-list-entry}", String.valueOf(versionListEntry));
+			}
+			if (isb.indexOf("${major}") >= 0)
+				replaceToken(isb, "${major}", String.valueOf(v.getMajor()));
+			if (isb.indexOf("${minor}") >= 0)
+				replaceToken(isb, "${minor}", String.valueOf(v.getMinor()));
+			sb.insert(tokStart, isb.toString());
+			tokStart += isb.length();
+		}							
+	}
+
+	// Model-level template processing
+	abstract protected void processTemplateA(String[] template)
+        throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+        	IllegalAccessException, InvocationTargetException;
+	
+	// Class-level template processing
+	abstract protected void processTemplateB(String[] template, AmqpClass thisClass)
+	    throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+	        IllegalAccessException, InvocationTargetException;
+	
+	// Method-level template processing
+	abstract protected void processTemplateC(String[] template, AmqpClass thisClass,
+		AmqpMethod method)
+	    throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+	    	IllegalAccessException, InvocationTargetException;
+	
+	// Field-level template processing
+	abstract protected void processTemplateD(String[] template, AmqpClass thisClass,
+		AmqpMethod method, AmqpField field)
+	    throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+	    	IllegalAccessException, InvocationTargetException;
+	
+	// Helper functions common to all generators
+	
+	protected static void prepareTargetDirectory(File dir, boolean createFlag)
+	    throws TargetDirectoryException
+	{
+		if (dir.exists())
+		{
+			if (!dir.isDirectory())
+				throw new TargetDirectoryException("\"" + dir.getAbsolutePath() +
+						"\" exists, but is not a directory.");
+		}
+		else if (createFlag) // Create dir
+		{
+			if(!dir.mkdirs())
+				throw new TargetDirectoryException("Unable to create directory \"" +
+						dir.getAbsolutePath() + "\".");
+		}
+		else
+			throw new TargetDirectoryException("Directory \"" + dir.getAbsolutePath() +
+					"\" not found.");
+			
+	}
+
+	protected void processAllLists(StringBuffer sb, AmqpClass thisClass, AmqpMethod method, AmqpVersion version)
+	    throws AmqpTemplateException, AmqpTypeMappingException, IllegalAccessException,
+	    	InvocationTargetException
+	{
+		int lstart = sb.indexOf("%{");
+		while (lstart != -1)
+		{
+			int lend = sb.indexOf("}", lstart + 2);
+			if (lend > 0)
+			{
+				String listToken = sb.substring(lstart + 2, lend);
+				if (listToken.compareTo("VLIST") == 0)
+				{
+					processVersionList(sb, lstart, lend + 1);
+				}
+				else if (listToken.compareTo("CLIST") == 0)
+				{
+					processClassList(sb, lstart, lend + 1, model);
+				}
+				else if (listToken.compareTo("MLIST") == 0)
+				{
+					processMethodList(sb, lstart, lend + 1, thisClass);
+				}
+				else if (listToken.compareTo("FLIST") == 0)
+				{
+					// Pass the FieldMap from either a class or a method.
+					// If this is called from a class-level template, we assume that the
+					// class field list is required. In this case, method will be null.
+					processFieldList(sb, lstart, lend + 1,
+						(method == null ? thisClass.fieldMap : method.fieldMap),
+						version);
+				}
+                else if (listToken.compareTo("TLIST") == 0)
+                {
+                    processConstantList(sb, lstart, lend + 1, globalConstantSet);
+                }
+				else
+				{
+					throw new AmqpTemplateException("Unknown list token \"%{" + listToken +
+						"}\" found in template at index " + lstart + ".");
+				}
+			}
+			lstart = sb.indexOf("%{", lstart + 1);
+		}		
+	}
+	
+	protected void processAllTokens(StringBuffer sb, AmqpClass thisClass, AmqpMethod method, AmqpField field,
+		AmqpVersion version)
+        throws AmqpTemplateException, AmqpTypeMappingException
+	{
+		int lstart = sb.indexOf("${");
+		while (lstart != -1)
+		{
+			int lend = sb.indexOf("}", lstart + 2);
+			if (lend > 0)
+			{
+				String token = sb.substring(lstart, lend + 1);
+				replaceToken(sb, lstart, token, processToken(token, thisClass, method, field, version));
+			}
+			lstart = sb.indexOf("${", lstart);
+		}			
+	}
+	
+	protected static void writeTargetFile(StringBuffer sb, File f)
+	    throws IOException
+	{
+		FileWriter fw = new FileWriter(f);
+		fw.write(sb.toString().toCharArray());
+		fw.flush();
+		fw.close();
+	}
+	
+	protected static String getTemplateFileName(StringBuffer sb)
+	    throws AmqpTemplateException
+	{
+		if (sb.charAt(0) != '&')
+			throw new AmqpTemplateException("No filename marker &{filename} found at start of template.");
+		int cr = sb.indexOf(Utils.lineSeparator);
+		if (cr < 0)
+			throw new AmqpTemplateException("Bad template structure - unable to find first line.");
+		String fileName = sb.substring(2, cr-1);
+		sb.delete(0, cr + 1);
+		return fileName;
+	}
+
+	protected static void replaceToken(StringBuffer sb, String token, String replacement)
+	{
+		replaceToken(sb, 0, token, replacement);
+	}
+
+	protected static void replaceToken(StringBuffer sb, int index, String token, String replacement)
+	{
+		if (replacement != null)
+		{
+			int start = sb.indexOf(token, index);
+			int len = token.length();
+			// Find first letter in token and determine if it is capitalized
+			char firstTokenLetter = getFirstLetter(token);
+			if (firstTokenLetter != 0 && Character.isUpperCase(firstTokenLetter))
+				sb.replace(start, start+len, Utils.firstUpper(replacement));
+			else
+				sb.replace(start, start+len, replacement);
+		}
+	}
+	
+	private static char getFirstLetter(String str)
+	{
+		int len = str.length();
+		int index = 0;
+		char tokChar = str.charAt(index);
+		while (!Character.isLetter(tokChar) && index<len-1)
+			tokChar = str.charAt(++index);
+		if (Character.isLetter(tokChar))
+			return tokChar;
+		return 0;
+	}
+	
+	private static String loadTemplate(File f)
+	    throws FileNotFoundException, IOException
+	{
+		StringBuffer sb = new StringBuffer();
+		FileReader fr = new FileReader(f);
+		LineNumberReader lnr = new LineNumberReader(fr);
+		String line = lnr.readLine();
+		while (line != null)
+		{
+			// Strip lines starting with '#' in template - treat these lines as template comments
+//			if (line.length() > 0 && line.charAt(0) != '#') // Bad idea - '#' used in C/C++ files (#include)!
+			if (line.length() > 0)
+				sb.append(line + Utils.lineSeparator);
+			else
+				sb.append(Utils.lineSeparator);
+			line = lnr.readLine();
+		}
+		lnr.close();
+		fr.close();
+		return sb.toString();
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/JavaGenerator.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/JavaGenerator.java
new file mode 100644
index 0000000000..9acfaf65fa
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/JavaGenerator.java
@@ -0,0 +1,1702 @@
+/*
+ *
+ * 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.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Iterator;
+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
+	{
+		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>();
+
+	// Methods used for generation of code snippets called from the field map parsers
+	
+	// Common methods
+	static private Method declarationGenerateMethod;
+	static private Method mangledDeclarationGenerateMethod;
+	
+	// Methods for MessageBody classes
+	static private Method mbGetGenerateMethod;
+	static private Method mbMangledGetGenerateMethod;
+	static private Method mbParamListGenerateMethod;
+	static private Method mbPassedParamListGenerateMethod;
+	static private Method mbMangledParamListGenerateMethod;
+	static private Method mbMangledPassedParamListGenerateMethod;
+	static private Method mbBodyInitGenerateMethod;
+	static private Method mbMangledBodyInitGenerateMethod;
+	static private Method mbSizeGenerateMethod;
+	static private Method mbBitSizeGenerateMethod;
+	static private Method mbEncodeGenerateMethod;
+	static private Method mbBitEncodeGenerateMethod;
+	static private Method mbDecodeGenerateMethod;
+	static private Method mbBitDecodeGenerateMethod;
+	static private Method mbToStringGenerateMethod;
+	static private Method mbBitToStringGenerateMethod;
+	
+	// Methods for PropertyContentHeader classes
+	static private Method pchClearGenerateMethod;
+	static private Method pchMangledClearGenerateMethod;
+	static private Method pchGetGenerateMethod;
+	static private Method pchMangledGetGenerateMethod;
+	static private Method pchSetGenerateMethod;
+	static private Method pchMangledSetGenerateMethod;
+	static private Method pchSizeGenerateMethod;
+	static private Method pchBitSizeGenerateMethod;
+	static private Method pchEncodeGenerateMethod;
+	static private Method pchBitEncodeGenerateMethod;
+	static private Method pchDecodeGenerateMethod;
+	static private Method pchBitDecodeGenerateMethod;
+	static private Method pchGetPropertyFlagsGenerateMethod;
+	static private Method pchBitGetPropertyFlagsGenerateMethod;
+	static private Method pchSetPropertyFlagsGenerateMethod;
+	static private Method pchBitSetPropertyFlagsGenerateMethod;
+	
+	static 
+	{
+		// **************
+		// Common methods
+		// **************
+		
+		// Methods for AmqpFieldMap.parseFieldMap()
+		
+		try { declarationGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+		    "generateFieldDeclaration", String.class, AmqpField.class,
+			AmqpVersionSet.class, int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mangledDeclarationGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMangledFieldDeclaration", AmqpField.class,
+			int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		
+		// *******************************
+		// Methods for MessageBody classes
+		// *******************************
+		
+		// Methods for AmqpFieldMap.parseFieldMap()
+		
+		try { mbGetGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+		    "generateMbGetMethod", String.class, AmqpField.class,
+			AmqpVersionSet.class, int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbMangledGetGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbMangledGetMethod", AmqpField.class,
+			int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+
+		try { mbParamListGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbParamList", String.class, AmqpField.class,
+			AmqpVersionSet.class, int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		
+		try { mbPassedParamListGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbPassedParamList", String.class, AmqpField.class,
+			AmqpVersionSet.class, int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbMangledParamListGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbMangledParamList", AmqpField.class,
+			int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbMangledPassedParamListGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbMangledPassedParamList", AmqpField.class,
+			int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbBodyInitGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbBodyInit", String.class, AmqpField.class,
+			AmqpVersionSet.class, int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbMangledBodyInitGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbMangledBodyInit", AmqpField.class,
+			int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		// Methods for AmqpFieldMap.parseFieldMapOrdinally()
+		
+		try { mbSizeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbFieldSize", String.class, String.class,
+			int.class, int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbBitSizeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbBitArrayFieldSize", ArrayList.class, int.class,
+			int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbEncodeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbFieldEncode", String.class, String.class,
+			int.class, int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbBitEncodeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbBitFieldEncode", ArrayList.class, int.class,
+			int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbDecodeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbFieldDecode", String.class, String.class,
+			int.class, int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbBitDecodeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbBitFieldDecode", ArrayList.class, int.class,
+			int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbToStringGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbFieldToString", String.class, String.class,
+			int.class, int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { mbBitToStringGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generateMbBitFieldToString", ArrayList.class, int.class,
+			int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		// *****************************************
+		// Methods for PropertyContentHeader classes
+		// *****************************************
+		
+		// Methods for AmqpFieldMap.parseFieldMap()
+
+		try { pchClearGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+		    "generatePchClearMethod", String.class, AmqpField.class,
+			AmqpVersionSet.class, int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchMangledClearGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchMangledClearMethod", AmqpField.class,
+			int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+
+		try { pchSetGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+		    "generatePchSetMethod", String.class, AmqpField.class,
+			AmqpVersionSet.class, int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchMangledSetGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchMangledSetMethod", AmqpField.class,
+			int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+
+		try { pchGetGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+		    "generatePchGetMethod", String.class, AmqpField.class,
+			AmqpVersionSet.class, int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchMangledGetGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchMangledGetMethod", AmqpField.class,
+			int.class, int.class, boolean.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		// Methods for AmqpFieldMap.parseFieldMapOrdinally()
+			
+		try { pchSizeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchFieldSize", String.class, String.class,
+			int.class, int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchBitSizeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchBitArrayFieldSize", ArrayList.class, int.class,
+			int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchEncodeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchFieldEncode", String.class, String.class,
+			int.class, int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchBitEncodeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchBitFieldEncode", ArrayList.class, int.class,
+			int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchDecodeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchFieldDecode", String.class, String.class,
+			int.class, int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchBitDecodeGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchBitFieldDecode", ArrayList.class, int.class,
+			int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchGetPropertyFlagsGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchGetPropertyFlags", String.class, String.class,
+			int.class, int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchBitGetPropertyFlagsGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchBitGetPropertyFlags", ArrayList.class, int.class,
+			int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchSetPropertyFlagsGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchSetPropertyFlags", String.class, String.class,
+			int.class, int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+		
+		try { pchBitSetPropertyFlagsGenerateMethod = JavaGenerator.class.getDeclaredMethod(
+			"generatePchBitSetPropertyFlags", ArrayList.class, int.class,
+			int.class, int.class); }
+		catch (NoSuchMethodException e) { e.printStackTrace(); }
+	}
+	
+	public JavaGenerator(AmqpVersionSet versionList)
+	{
+		super(versionList);
+		// 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
+			"EncodingUtils.writeBooleans(buffer, #)",		// encode expression
+			"# = EncodingUtils.readBooleans(buffer)"));		// decode expression
+		typeMap.put("content", new DomainInfo(
+			"Content",										// Java code type
+			"EncodingUtils.encodedContentLength(#)", 	// size
+			"EncodingUtils.writeContentBytes(buffer, #)", // encode expression
+			"# = EncodingUtils.readContent(buffer)"));	// decode expression
+		typeMap.put("long", new DomainInfo(
+			"long",											// Java code type
+			"4",											// size
+			"EncodingUtils.writeUnsignedInteger(buffer, #)", // encode expression
+			"# = buffer.getUnsignedInt()")); 				// decode expression
+		typeMap.put("longlong", new DomainInfo(
+			"long",											// Java code type
+			"8",											// size
+			"buffer.putLong(#)", 							// encode expression
+			"# = buffer.getLong()")); 						// decode expression
+		typeMap.put("longstr", new DomainInfo(
+			"byte[]",										// Java code type
+			"EncodingUtils.encodedLongstrLength(#)", 		// size
+			"EncodingUtils.writeLongStringBytes(buffer, #)", // encode expression
+			"# = EncodingUtils.readLongstr(buffer)"));		// decode expression
+		typeMap.put("octet", new DomainInfo(
+			"short",										// Java code type
+			"1",											// size
+			"EncodingUtils.writeUnsignedByte(buffer, #)",	// encode expression
+			"# = buffer.getUnsigned()")); 					// decode expression
+		typeMap.put("short", new DomainInfo(
+			"int",											// Java code type
+			"2",											// size
+			"EncodingUtils.writeUnsignedShort(buffer, #)",	// encode expression
+			"# = buffer.getUnsignedShort()")); 				// decode expression
+		typeMap.put("shortstr", new DomainInfo(
+			"AMQShortString",										// Java code type
+			"EncodingUtils.encodedShortStringLength(#)",	// size
+			"EncodingUtils.writeShortStringBytes(buffer, #)", // encode expression
+			"# = EncodingUtils.readAMQShortString(buffer)"));	// decode expression
+		typeMap.put("table", new DomainInfo(
+			"FieldTable",									// Java code type
+			"EncodingUtils.encodedFieldTableLength(#)", 	// size
+			"EncodingUtils.writeFieldTableBytes(buffer, #)", // encode expression
+			"# = EncodingUtils.readFieldTable(buffer)"));	// decode expression
+		typeMap.put("timestamp", new DomainInfo(
+			"long",											// Java code type
+			"8",											// size
+			"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 getDomainType(String domainName, AmqpVersion version)
+		throws AmqpTypeMappingException
+	{
+		return globalDomainMap.getDomainType(domainName, version);
+	}
+	
+	public String getGeneratedType(String domainName, AmqpVersion version)
+		throws AmqpTypeMappingException
+	{
+		String domainType = globalDomainMap.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)
+	{
+		StringBuffer sb = new StringBuffer(filenameTemplate);
+		if (thisClass != null)
+			replaceToken(sb, "${CLASS}", thisClass.name);
+		if (method != null)
+			replaceToken(sb, "${METHOD}", method.name);
+		if (field != null)
+			replaceToken(sb, "${FIELD}", field.name);
+		return sb.toString();
+	}
+	
+	@Override
+	protected void processTemplateA(String[] template)
+	    throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+	    	IllegalAccessException, InvocationTargetException
+   	{
+		processTemplateD(template, null, null, null);
+  	}
+	
+	@Override
+	protected void processTemplateB(String[] template, AmqpClass thisClass)
+	    throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+	    	IllegalAccessException, InvocationTargetException
+	{
+		processTemplateD(template, thisClass, null, null);
+	}
+	
+	@Override
+	protected void processTemplateC(String[] template, AmqpClass thisClass,
+		AmqpMethod method)
+	    throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+	    	IllegalAccessException, InvocationTargetException
+	{
+		processTemplateD(template, thisClass, method, null);
+	}
+	
+	@Override
+	protected void processTemplateD(String[] template, AmqpClass thisClass,
+		AmqpMethod method, AmqpField field)
+	    throws IOException, AmqpTemplateException, AmqpTypeMappingException,
+	    	IllegalAccessException, InvocationTargetException
+	{
+		StringBuffer sb = new StringBuffer(template[1]);
+		String filename = prepareFilename(getTemplateFileName(sb), thisClass, method, field);
+		processTemplate(sb, thisClass, method, field, template[templateFileNameIndex], null);
+		writeTargetFile(sb, new File(genDir + Utils.fileSeparator + filename));
+		generatedFileCounter ++;
+	}
+	
+	protected void processTemplate(StringBuffer sb, AmqpClass thisClass, AmqpMethod method,
+		AmqpField field, String templateFileName, AmqpVersion version)
+		throws InvocationTargetException, IllegalAccessException, AmqpTypeMappingException
+	{
+		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)
+	    throws AmqpTemplateException, AmqpTypeMappingException
+	{
+		if (token.compareTo("${GENERATOR}") == 0)
+			return generatorInfo;
+		if (token.compareTo("${CLASS}") == 0 && thisClass != null)
+			return thisClass.name;
+		if (token.compareTo("${CLASS_ID_INIT}") == 0 && thisClass != null)
+			return generateIndexInitializer("registerClassId", thisClass.indexMap, 8);
+		if (token.compareTo("${METHOD}") == 0 && method != null)
+			return method.name;
+		if (token.compareTo("${METHOD_ID_INIT}") == 0 && method != null)
+			return generateIndexInitializer("registerMethodId", method.indexMap, 8);
+		if (token.compareTo("${FIELD}") == 0 && field != null)
+			return field.name;
+		
+		// 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.fieldMap.size() : method.fieldMap.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)
+	    throws AmqpTemplateException, AmqpTypeMappingException
+	{
+		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)
+        throws AmqpTemplateException, AmqpTypeMappingException
+	{
+		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)
+	    throws AmqpTypeMappingException, AmqpTemplateException, IllegalAccessException,
+	    	InvocationTargetException
+	{
+		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)
+        throws AmqpTemplateException, AmqpTypeMappingException
+
+        {
+        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.name +
+			"; // AMQP version(s): " + versionSet + cr;
+	}
+
+	protected String generateMangledFieldDeclaration(AmqpField field, int indentSize,
+		int tabSize, boolean nextFlag)
+	    throws AmqpTypeMappingException
+	{
+		StringBuffer sb = new StringBuffer();
+		Iterator<String> dItr = field.domainMap.keySet().iterator();
+		int domainCntr = 0;
+		while (dItr.hasNext())
+		{
+			String domainName = dItr.next();
+			AmqpVersionSet versionSet = field.domainMap.get(domainName);
+			String codeType = getGeneratedType(domainName, versionSet.first());
+			sb.append(Utils.createSpaces(indentSize) + "public " + codeType + " " +
+				field.name + "_" + (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();
+		
+        for (Integer index : indexMap.keySet())
+		{
+			AmqpVersionSet versionSet = indexMap.get(index);
+            for (AmqpVersion version : versionSet)
+			{
+				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.classMap.keySet())
+		{
+			AmqpClass thisClass = model.classMap.get(className);
+			for (String methodName : thisClass.methodMap.keySet())
+			{
+				AmqpMethod method = thisClass.methodMap.get(methodName);
+				for (AmqpVersion version : globalVersionSet)
+				{
+					// Find class and method index for this version (if it exists)
+					try
+					{
+						int classIndex = findIndex(thisClass.indexMap, version);
+						int methodIndex = findIndex(method.indexMap, 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.name) +
+							Utils.firstUpper(method.name) + "Body.getFactory());" + cr);
+					}
+					catch (Exception e) {} // Ignore
+				}
+			}
+		}
+		return sb.toString();
+	}
+	
+	protected int findIndex(TreeMap<Integer, AmqpVersionSet> map, AmqpVersion version)
+	    throws Exception
+	{
+		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 Exception("Index not found");
+	}
+    
+    // Methods for AmqpConstants class
+   
+    protected String generateConstantGetMethods(AmqpConstantSet constantSet,
+        int indentSize, int tabSize)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        StringBuffer sb = new StringBuffer();
+        Iterator<AmqpConstant> cItr = constantSet.iterator();
+        while (cItr.hasNext())
+        {
+            AmqpConstant constant = cItr.next();
+            if (constant.isVersionConsistent(globalVersionSet))
+            {
+                // return a constant
+                String value = constant.firstKey();
+                sb.append(indent + "public static String " + constant.name + "() { return \"" +
+                    constant.firstKey() + "\"; }" + cr);
+                if (Utils.containsOnlyDigits(value))
+                {
+                    sb.append(indent + "public static int " + constant.name + "AsInt() { return " +
+                        constant.firstKey() + "; }" + cr);
+                }
+                if (Utils.containsOnlyDigitsAndDecimal(value))
+                {
+                    sb.append(indent + "public static double " + constant.name + "AsDouble() { return (double)" +
+                        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)
+        throws AmqpTypeMappingException
+    {
+        String indent = Utils.createSpaces(indentSize);
+        String tab = Utils.createSpaces(tabSize);
+        StringBuffer sb = new StringBuffer();
+        sb.append(indent + "public static " + methodReturnType + " " + constant.name +
+            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.name, methodReturnType,
+                    indentSize + (2*tabSize), tabSize));
+            }
+            else if (methodReturnType.compareTo("double") == 0 && !Utils.containsOnlyDigitsAndDecimal(value))
+            {
+                sb.append(generateConstantDeclarationException(constant.name, 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.name + "\\\" \" +" + 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.name) + "() { return " + field.name + "; }" +
+			cr;
+	}
+	
+	protected String generateMbMangledGetMethod(AmqpField field, int indentSize,
+		int tabSize, boolean nextFlag)
+		throws AmqpTypeMappingException
+	{
+		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.name) +
+				"(Class<T> classObj) throws AMQProtocolVersionException" + cr);
+		sb.append(indent + "{" + cr);		
+		Iterator<String> dItr = field.domainMap.keySet().iterator();
+		int domainCntr = 0;
+		while (dItr.hasNext())
+		{
+			String domainName = dItr.next();
+			AmqpVersionSet versionSet = field.domainMap.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.name + "_" +
+				(domainCntr++) + ";" + cr);
+		}
+		sb.append(indent + tab +
+		"throw new AMQProtocolVersionException(\"None of the AMQP versions defines \" +" +
+		cr + "            \"field \\\"" + field.name +
+		"\\\" 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.name +
+			(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.name +
+			(nextFlag ? "," : "") + " // AMQP version(s): " + versionSet + cr;
+	}
+	
+	
+	protected String generateMbMangledParamList(AmqpField field, int indentSize,
+		int tabSize, boolean nextFlag)
+		throws AmqpTypeMappingException
+	{
+		StringBuffer sb = new StringBuffer();
+		Iterator<String> dItr = field.domainMap.keySet().iterator();
+		int domainCntr = 0;
+		while (dItr.hasNext())
+		{
+			String domainName = dItr.next();
+			AmqpVersionSet versionSet = field.domainMap.get(domainName);
+			String codeType = getGeneratedType(domainName, versionSet.first());
+			sb.append(Utils.createSpaces(indentSize) + codeType + " " + field.name + "_" +
+				(domainCntr++) + (nextFlag ? "," : "") + " // AMQP version(s): " +
+				versionSet + cr);
+		}
+		return sb.toString();		
+	}
+	
+	protected String generateMbMangledPassedParamList(AmqpField field, int indentSize,
+		int tabSize, boolean nextFlag)
+		throws AmqpTypeMappingException
+	{
+		StringBuffer sb = new StringBuffer();
+		Iterator<String> dItr = field.domainMap.keySet().iterator();
+		int domainCntr = 0;
+		while (dItr.hasNext())
+		{
+			String domainName = dItr.next();
+			AmqpVersionSet versionSet = field.domainMap.get(domainName);
+			sb.append(Utils.createSpaces(indentSize) + field.name + "_" +
+				(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.name + " = " + field.name +
+			";" + cr;
+	}
+	
+	protected String generateMbMangledBodyInit(AmqpField field, int indentSize,
+		int tabSize, boolean nextFlag)
+		throws AmqpTypeMappingException
+	{
+		StringBuffer sb = new StringBuffer();
+		Iterator<String> dItr = field.domainMap.keySet().iterator();
+		int domainCntr = 0;
+		while (dItr.hasNext())
+		{
+			dItr.next();
+			sb.append(Utils.createSpaces(indentSize) + "bodyFrame." + field.name + "_" + domainCntr +
+					" = " + field.name + "_" + (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(ArrayList<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(ArrayList<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(ArrayList<String> bitFieldList,
+		int ordinal, int indentSize, int tabSize)
+	{
+		String indent = Utils.createSpaces(indentSize);
+		
+		StringBuilder sb = new StringBuilder(indent);
+        // Multiple occurrences of byte value blocks will result in multiple declarations
+        // unless each is named uniquely.
+        String varName = "packedValue_" + ordinal;
+		sb.append("byte " + varName + ";");
+		sb.append(cr);
+		
+		// RG HERE!
+		
+		int i = 0;
+		while(i < bitFieldList.size())
+		{
+			sb.append(indent + varName + " = EncodingUtils.readByte(buffer);" + cr);
+			
+			for(int j = 0; i < bitFieldList.size() && j < 8; i++, j++)
+			{
+				sb.append(indent + bitFieldList.get(i) + " = ( " + varName + " & (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();
+        if (domain.compareTo("longstr") == 0)
+        {
+		    sb.append(Utils.createSpaces(indentSize) +
+			    "buf.append(\"  " + fieldName + ": \" + (" + fieldName +
+                " == null ? \"<null>\" : new String(" + fieldName + ")));" + cr);		
+        }
+        else
+        {
+		    sb.append(Utils.createSpaces(indentSize) +
+			    "buf.append(\"  " + fieldName + ": \" + " + fieldName + ");" + cr);		
+        }
+		return sb.toString();
+	}
+	
+	protected String generateMbBitFieldToString(ArrayList<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)
+		throws AmqpTypeMappingException
+	{
+		// 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)
+		throws AmqpTypeMappingException
+	{
+		String indent = Utils.createSpaces(indentSize);
+		String tab = Utils.createSpaces(tabSize);
+		StringBuffer sb = new StringBuffer();
+		sb.append(indent + "public void clear" + Utils.firstUpper(field.name) +
+				"()" + 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.ordinalMap.size() == 1 &&
+			field.ordinalMap.get(field.ordinalMap.firstKey()).size() == globalVersionSet.size())
+		{
+			int ordinal = field.ordinalMap.firstKey();
+			sb.append(indent + tab + "clearEncodedForm();" + cr);
+			sb.append(indent + tab + "propertyFlags[" + ordinal + "] = false;" + cr);
+		}
+		else
+		{
+			Iterator<Integer> oItr = field.ordinalMap.keySet().iterator();
+			while (oItr.hasNext())
+			{
+				int ordinal = oItr.next();
+				AmqpVersionSet versionSet = field.ordinalMap.get(ordinal);
+				sb.append(indent + tab);
+				if (ordinal != field.ordinalMap.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)
+		throws AmqpTypeMappingException
+	{
+		String indent = Utils.createSpaces(indentSize);
+		String tab = Utils.createSpaces(tabSize);
+		StringBuffer sb = new StringBuffer(indent + "public " + codeType + " get" +
+			Utils.firstUpper(field.name) + "()" + cr);
+		sb.append(indent + "{" + cr);
+		sb.append(indent + tab + "decodeIfNecessary();" + cr);
+		sb.append(indent + tab + "return " + field.name + ";" + cr);
+		sb.append(indent + "}" + cr);
+		sb.append(cr);		
+		return sb.toString();		
+	}
+		
+	protected String generatePchMangledGetMethod(AmqpField field, int indentSize,
+		int tabSize, boolean nextFlag)
+		throws AmqpTypeMappingException
+	{
+		String indent = Utils.createSpaces(indentSize);
+		String tab = Utils.createSpaces(tabSize);
+		StringBuffer sb = new StringBuffer(indent + "public <T> T get" +
+			Utils.firstUpper(field.name) +
+			"(Class<T> classObj) throws AMQProtocolVersionException" + cr);
+		sb.append(indent + "{" + cr);		
+		Iterator<String> dItr = field.domainMap.keySet().iterator();
+		int domainCntr = 0;
+		while (dItr.hasNext())
+		{
+			String domainName = dItr.next();
+			AmqpVersionSet versionSet = field.domainMap.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.name + "_" +
+				(domainCntr++) + ";" + cr);
+			sb.append(indent + tab + "}" + cr);		
+		}
+		sb.append(indent + tab +
+		    "throw new AMQProtocolVersionException(\"None of the AMQP versions defines \" +" +
+			cr + "            \"field \\\"" + field.name +
+			"\\\" 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)
+		throws AmqpTypeMappingException
+	{
+		String indent = Utils.createSpaces(indentSize);
+		String tab = Utils.createSpaces(tabSize);
+		StringBuffer sb = new StringBuffer();
+		sb.append(indent + "public void set" + Utils.firstUpper(field.name) +
+		    "(" + codeType + " " + field.name + ")" + 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.ordinalMap.size() == 1 &&
+			field.ordinalMap.get(field.ordinalMap.firstKey()).size() == globalVersionSet.size())
+		{
+			int ordinal = field.ordinalMap.firstKey();
+			sb.append(indent + tab + "clearEncodedForm();" + cr);
+			sb.append(indent + tab + "propertyFlags[" + ordinal + "] = true;" + cr);
+			sb.append(indent + tab + "this." + field.name + " = " + field.name + ";" + cr);
+		}
+		else
+		{
+			Iterator<Integer> oItr = field.ordinalMap.keySet().iterator();
+			while (oItr.hasNext())
+			{
+				int ordinal = oItr.next();
+				AmqpVersionSet oVersionSet = field.ordinalMap.get(ordinal);
+				sb.append(indent + tab);
+				if (ordinal != field.ordinalMap.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.name + " = " + field.name + ";" + 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)
+		throws AmqpTypeMappingException
+	{
+		String indent = Utils.createSpaces(indentSize);
+		String tab = Utils.createSpaces(tabSize);
+		StringBuffer sb = new StringBuffer();
+		
+		Iterator<String> dItr = field.domainMap.keySet().iterator();
+		int domainCntr = 0;
+		while (dItr.hasNext())
+		{
+			String domainName = dItr.next();
+			AmqpVersionSet versionSet = field.domainMap.get(domainName);
+			String codeType = getGeneratedType(domainName, versionSet.first());
+			
+			// Find ordinal with matching version
+			AmqpVersionSet commonVersionSet = new AmqpVersionSet();
+			Iterator<Integer> oItr = field.ordinalMap.keySet().iterator();
+			while (oItr.hasNext())
+			{
+				int ordinal = oItr.next();
+				AmqpVersionSet oVersionSet = field.ordinalMap.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.name) +
+						    "(" + codeType + " " + field.name + ")" + 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.name + "_" + (domainCntr++) +
+						" = " + field.name + ";" + 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(ArrayList<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(ArrayList<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(ArrayList<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(ArrayList<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(ArrayList<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 = globalVersionSet.iterator();
+		while (vItr.hasNext())
+		{
+			AmqpVersion version = vItr.next();
+			int numBytes = ((thisClass.fieldMap.getNumFields(version) - 1) / 15) + 1;
+			
+			sb.append(indent);
+			if (!version.equals(globalVersionSet.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 = globalVersionSet.iterator();
+		while (vItr.hasNext())
+		{
+			AmqpVersion version = vItr.next();
+			int numFields = thisClass.fieldMap.getNumFields(version);
+			int numBytes = ((numFields - 1) / 15) + 1;
+			
+			sb.append(indent);
+			if (!version.equals(globalVersionSet.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)
+        throws AmqpTypeMappingException
+	{
+		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();
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/LanguageConverter.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/LanguageConverter.java
new file mode 100644
index 0000000000..cb0a14e3bc
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/LanguageConverter.java
@@ -0,0 +1,39 @@
+/*
+ *
+ * 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;
+
+public interface LanguageConverter
+{
+	public void setDomainMap(AmqpDomainMap domainMap);
+	public AmqpDomainMap getDomainMap();
+
+    public void setConstantSet(AmqpConstantSet constantSet);
+    public AmqpConstantSet getConstantSet();
+	
+	public void setModel(AmqpModel model);
+	public AmqpModel getModel();
+	
+	public String prepareClassName(String className);
+	public String prepareMethodName(String methodName);
+	public String prepareDomainName(String domainName);
+	public String getDomainType(String domainName, AmqpVersion version) throws AmqpTypeMappingException;
+	public String getGeneratedType(String domainName, AmqpVersion version) throws AmqpTypeMappingException;
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/Main.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/Main.java
new file mode 100644
index 0000000000..f1728ab290
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/Main.java
@@ -0,0 +1,353 @@
+/*
+ *
+ * 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.io.FileNotFoundException;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.xml.sax.SAXException;
+
+public class Main
+{
+    private static final String defaultOutDir = ".." + Utils.fileSeparator + "gen";
+    private static final String defaultCppTemplateDir = ".." + Utils.fileSeparator + "templ.cpp";
+    private static final String defaultDotnetTemplateDir = ".." + Utils.fileSeparator + "templ.net";
+    private static final String defaultJavaTemplateDir = ".." + Utils.fileSeparator + "templ.java";
+    
+    private enum GeneratorLangEnum { CPP, DOTNET, JAVA }
+    
+	private DocumentBuilder docBuilder;
+	private AmqpVersionSet versionSet;
+	private Generator generator;
+    private AmqpConstantSet constants;
+	private AmqpDomainMap domainMap;
+	private AmqpModel model;
+    
+    private String outDir;
+    private String tmplDir;
+    private GeneratorLangEnum generatorLang;
+    private ArrayList<String> xmlFiles;
+    private File[] modelTemplateFiles;
+    private File[] classTemplateFiles;
+    private File[] methodTemplateFiles;
+    private File[] fieldTemplateFiles;
+	
+	public Main() throws ParserConfigurationException
+	{
+		docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+		versionSet = new AmqpVersionSet();
+        xmlFiles = new ArrayList<String>();
+	}
+	
+	public void run(String[] args)
+		throws 	IOException,
+				SAXException,
+				AmqpParseException,
+				AmqpTypeMappingException,
+				AmqpTemplateException,
+				TargetDirectoryException,
+				IllegalAccessException,
+		    	InvocationTargetException
+	{
+		modelTemplateFiles = new File[]{};
+		classTemplateFiles = new File[]{};
+		methodTemplateFiles = new File[]{};
+		fieldTemplateFiles = new File[]{};
+        
+        // 0. Initialize
+        outDir = defaultOutDir;
+        tmplDir = null;
+        generatorLang = GeneratorLangEnum.CPP; // Default generation language
+        xmlFiles.clear();
+        processArgs(args);
+        switch (generatorLang)
+        {
+        case JAVA:
+        	prepareJava();
+        	break;
+        case DOTNET:
+        	prepareDotnet();
+        	break;
+        default:
+            prepareCpp();
+        }
+
+		if (modelTemplateFiles.length == 0 && classTemplateFiles.length == 0 &&
+			methodTemplateFiles.length == 0 && fieldTemplateFiles.length == 0)
+			System.err.println("  WARNING: No template files.");
+		
+		// 1. Suck in all the XML spec files provided on the command line
+        analyzeXML();
+		
+		// 2. Load up all templates
+        try
+        {
+		generator.initializeTemplates(modelTemplateFiles, classTemplateFiles,
+			methodTemplateFiles, fieldTemplateFiles);
+        }
+        catch (FileNotFoundException e)
+        {
+        	System.err.println("Error: Unable to load template file (check -t option on command-line):");
+        	System.err.println(e.getMessage());
+        	return;
+        }
+		
+		// 3. Generate output
+		generator.generate(new File(outDir));
+		
+		System.out.println("Files generated: " + generator.getNumberGeneratedFiles());
+		System.out.println("Done.");
+	}
+
+    private void processArgs(String[] args)
+    {
+        // Crude but simple...
+        for (int i=0; i<args.length; i++)
+        {
+            String arg = args[i];
+            if (arg.charAt(0) == '-')
+            {
+                switch (arg.charAt(1))
+                {
+                    case 'c':
+                    case 'C':
+                    	generatorLang = GeneratorLangEnum.CPP;
+                        break;
+                    case 'j':
+                    case 'J':
+                    	generatorLang = GeneratorLangEnum.JAVA;
+                        break;
+                    case 'n':
+                    case 'N':
+                    	generatorLang = GeneratorLangEnum.DOTNET;
+                        break;
+                    case 'o':
+                    case 'O':
+                        if (++i < args.length)
+                        {
+                            outDir = args[i];
+                        }
+                       break;
+                    case 't':
+                    case 'T':
+                        if (++i < args.length)
+                        {
+                            tmplDir = args[i];
+                        }
+                        break;
+                }
+            }
+            else
+            {
+                xmlFiles.add(args[i]);
+            }
+        }
+    }
+    
+    private void prepareJava()
+    {
+        if (tmplDir == null)
+            tmplDir = defaultJavaTemplateDir;
+        System.out.println("Java generation mode.");
+        generator = new JavaGenerator(versionSet);
+        constants = new AmqpConstantSet(generator);
+        domainMap = new AmqpDomainMap(generator);
+        model = new AmqpModel(generator);       
+        modelTemplateFiles = new File[]
+        {
+            new File(tmplDir + Utils.fileSeparator + "MethodRegistryClass.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "AmqpConstantsClass.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "ProtocolVersionListClass.tmpl")
+        };
+        classTemplateFiles = new File[]
+        {
+//            new File(tmplDir + Utils.fileSeparator + "PropertyContentHeaderClass.tmpl")
+        };
+        methodTemplateFiles = new File[]
+        {
+            new File(tmplDir + Utils.fileSeparator + "MethodBodyClass.tmpl")
+        };
+    }
+    
+    private void prepareDotnet()
+    {
+        if (tmplDir == null)
+            tmplDir = defaultDotnetTemplateDir;
+        System.out.println(".NET generation mode.");
+        generator = new DotnetGenerator(versionSet);
+        constants = new AmqpConstantSet(generator);
+        domainMap = new AmqpDomainMap(generator);
+        model = new AmqpModel(generator);       
+    	// TODO: Add templated that should be handled in here...
+       modelTemplateFiles = new File[]
+        {
+//          new File(tmplDir + Utils.fileSeparator + "XXXClass.tmpl"),
+        };
+        classTemplateFiles = new File[]
+        {
+//          new File(tmplDir + Utils.fileSeparator + "XXXClass.tmpl"),
+        };
+        methodTemplateFiles = new File[]
+        {
+//          new File(tmplDir + Utils.fileSeparator + "XXXClass.tmpl"),
+        };
+   }
+   
+    private void prepareCpp()
+    {
+        if (tmplDir == null)
+            tmplDir = defaultCppTemplateDir;
+        System.out.println("C++ generation mode.");
+        generator = new CppGenerator(versionSet);
+        constants = new AmqpConstantSet(generator);
+        domainMap = new AmqpDomainMap(generator);
+        model = new AmqpModel(generator);           
+        modelTemplateFiles = new File[]
+        {
+            new File(tmplDir + Utils.fileSeparator + "AMQP_ServerOperations.h.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "AMQP_ClientOperations.h.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "AMQP_ServerProxy.h.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "AMQP_ClientProxy.h.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "AMQP_ServerProxy.cpp.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "AMQP_ClientProxy.cpp.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "AMQP_Constants.h.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "AMQP_MethodVersionMap.h.tmpl"),
+            new File(tmplDir + Utils.fileSeparator + "AMQP_MethodVersionMap.cpp.tmpl"),
+           new File(tmplDir + Utils.fileSeparator + "AMQP_HighestVersion.h.tmpl")
+        };
+        methodTemplateFiles = new File[]
+        {
+            new File(tmplDir + Utils.fileSeparator + "MethodBodyClass.h.tmpl")
+        };        
+    }
+
+    private void analyzeXML()
+        throws IOException, SAXException, AmqpParseException, AmqpTypeMappingException
+    {
+        System.out.println("XML files: " + xmlFiles);
+        for (String filename : xmlFiles)
+        {
+            File f = new File(filename);
+            if (f.exists())
+            {
+                // 1a. Initialize dom
+                System.out.print("  \"" + filename + "\":");
+                Document doc = docBuilder.parse(new File(filename));
+                Node amqpNode = Utils.findChild(doc, Utils.ELEMENT_AMQP);
+                
+                // 1b. Extract version (major and minor) from the XML file
+                int major = Utils.getNamedIntegerAttribute(amqpNode, Utils.ATTRIBUTE_MAJOR);
+                int minor = Utils.getNamedIntegerAttribute(amqpNode, Utils.ATTRIBUTE_MINOR);
+                AmqpVersion version = new AmqpVersion(major, minor);
+                System.out.println(" Found version " + version.toString() + ".");
+                versionSet.add(version);
+                
+                // 1c. Extract domains
+                constants.addFromNode(amqpNode, 0, version);
+                
+                // 1d. Extract domains
+                domainMap.addFromNode(amqpNode, 0, version);
+                
+                // 1e. Extract class/method/field heirarchy
+                model.addFromNode(amqpNode, 0, version);
+            }
+            else
+                System.err.println("ERROR: AMQP XML file \"" + filename + "\" not found.");
+        }
+// *** DEBUG INFO ***  Uncomment bits from this block to see lots of stuff....
+//      System.out.println();
+//      System.out.println("*** Debug output ***");
+//      System.out.println();
+//      versionSet.print(System.out, 0, 2); // List of loaded versions
+//      System.out.println();
+//      constants.print(System.out, 0, 2); // List of constants
+//      System.out.println();
+//      domainMap.print(System.out, 0, 2); // List of domains
+//      System.out.println();
+//      model.print(System.out, 0, 2); // Internal version map model
+//      System.out.println();
+//      System.out.println("*** End debug output ***");
+//      System.out.println();        
+    }
+    
+	public static void main(String[] args)
+	{
+		int exitCode = 1;
+		// TODO: This is a simple and klunky way of hangling command-line args, and could be improved upon.
+		if (args.length < 2)
+		{
+			usage();
+		}
+		else
+		{
+			try
+			{
+				new Main().run(args);
+				exitCode = 0;
+			}
+			catch (IOException e) { e.printStackTrace(); }
+			catch (ParserConfigurationException e) { e.printStackTrace(); }
+			catch (SAXException e) { e.printStackTrace(); }
+			catch (AmqpParseException e) { e.printStackTrace(); }
+			catch (AmqpTypeMappingException e) { e.printStackTrace(); }
+			catch (AmqpTemplateException e) { e.printStackTrace(); }
+			catch (TargetDirectoryException e) { e.printStackTrace(); }
+			catch (IllegalAccessException e) { e.printStackTrace(); }
+			catch (InvocationTargetException e) { e.printStackTrace(); }
+		}
+		System.exit(exitCode);
+	}
+
+	public static void usage()
+	{
+		System.out.println("AMQP XML generator v.0.0");
+		System.out.println("Usage: Main -c|-j [-o outDir] [-t tmplDir] XMLfile [XMLfile ...]");
+		System.out.println("       where -c:         Generate C++.");
+		System.out.println("             -j:         Generate Java.");
+		System.out.println("             -n:         Generate .NET.");
+        System.out.println("             -o outDir:  Use outDir as the output dir (default=\"" + defaultOutDir + "\").");
+        System.out.println("             -t tmplDir: Find templates in tmplDir.");
+        System.out.println("                         Defaults: \"" + defaultCppTemplateDir + "\" for C++;");
+        System.out.println("                                   \"" + defaultJavaTemplateDir + "\" for java.");
+		System.out.println("             XMLfile is a space-separated list of AMQP XML files to be parsed.");
+	}
+	
+	public static String ListTemplateList(File[] list)
+	{
+		StringBuffer sb = new StringBuffer();
+		for (int i=0; i<list.length; i++)
+		{
+			if (i != 0)
+				sb.append(", ");
+			sb.append(list[i].getName());
+		}
+		return sb.toString();
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/NodeAware.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/NodeAware.java
new file mode 100644
index 0000000000..df4e0ecb02
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/NodeAware.java
@@ -0,0 +1,46 @@
+/*
+ *
+ * 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 org.w3c.dom.Node;
+
+/**
+ * @author kpvdr
+ * Interface allowing the addition of elements from a node in the
+ * DOM of the AMQP specification. It is used by each of the model
+ * elements in a recursive fashion to build the model.
+ */
+public interface NodeAware
+{
+	/**
+	 * Add a model element from the current DOM node. All model elements must implement
+	 * this interface. If the node contains children that are also a part of the model,
+	 * then this method is called on new instances of those model elements.
+	 * @param n Node from which the current model element is to be added.
+	 * @param o Ordinal value of the current model elemet.
+	 * @param v Verion of the DOM from which the node comes.
+	 * @throws AmqpParseException
+	 * @throws AmqpTypeMappingException
+	 * @returns true if a node was added, false if not
+	 */
+	public boolean addFromNode(Node n, int o, AmqpVersion v)
+		throws AmqpParseException, AmqpTypeMappingException;
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/Printable.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/Printable.java
new file mode 100644
index 0000000000..a73878c506
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/Printable.java
@@ -0,0 +1,28 @@
+/*
+ *
+ * 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.PrintStream;
+
+public interface Printable
+{
+	public void print(PrintStream out, int marginSize, int tabSize);
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/TargetDirectoryException.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/TargetDirectoryException.java
new file mode 100644
index 0000000000..cdaf381f0a
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/TargetDirectoryException.java
@@ -0,0 +1,30 @@
+/*
+ *
+ * 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;
+
+@SuppressWarnings("serial")
+public class TargetDirectoryException extends Exception
+{
+	public TargetDirectoryException(String msg)
+	{
+		super(msg);
+	}
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/Utils.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/Utils.java
new file mode 100644
index 0000000000..ade00cd8c7
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/Utils.java
@@ -0,0 +1,146 @@
+/*
+ *
+ * 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 org.w3c.dom.Attr;
+//import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+public class Utils
+{
+	public final static String fileSeparator = System.getProperty("file.separator");
+	public final static String lineSeparator = System.getProperty("line.separator");
+	
+	public final static String ATTRIBUTE_NAME = "name";
+	public final static String ATTRIBUTE_MAJOR = "major";
+	public final static String ATTRIBUTE_MINOR = "minor";
+	public final static String ATTRIBUTE_INDEX = "index";
+	public final static String ATTRIBUTE_LABEL = "label";
+	public final static String ATTRIBUTE_SYNCHRONOUS = "synchronous";
+	public final static String ATTRIBUTE_CONTENT = "content";
+	public final static String ATTRIBUTE_HANDLER = "handler";
+	public final static String ATTRIBUTE_DOMAIN = "domain";
+    public final static String ATTRIBUTE_VALUE = "value";
+	public final static String ATTRIBUTE_TYPE = "type"; // For compatibility with AMQP 8.0
+	
+	public final static String ELEMENT_AMQP = "amqp";
+	public final static String ELEMENT_CHASSIS = "chassis";
+	public final static String ELEMENT_CLASS = "class";
+	public final static String ELEMENT_CODEGEN = "codegen";
+    public final static String ELEMENT_CONSTANT = "constant";
+	public final static String ELEMENT_DOMAIN = "domain";
+	public final static String ELEMENT_METHOD = "method";
+	public final static String ELEMENT_FIELD = "field";
+	public final static String ELEMENT_VERSION = "version";
+	
+	// Attribute functions
+	
+	public static String getNamedAttribute(Node n, String attrName) throws AmqpParseException
+	{
+		NamedNodeMap nnm = n.getAttributes();
+		if (nnm == null)
+			throw new AmqpParseException("Node \"" + n.getNodeName() + "\" has no attributes.");
+		Attr a = (Attr)nnm.getNamedItem(attrName);
+		if (a == null)
+			throw new AmqpParseException("Node \"" + n.getNodeName() + "\" has no attribute \"" + attrName + "\".");
+		return a.getNodeValue();
+	}
+	
+	public static int getNamedIntegerAttribute(Node n, String attrName) throws AmqpParseException
+	{
+		return Integer.parseInt(getNamedAttribute(n, attrName));
+	}
+	
+	// Element functions
+	
+	public static Node findChild(Node n, String eltName) throws AmqpParseException
+	{
+		NodeList nl = n.getChildNodes();
+		for (int i=0; i<nl.getLength(); i++)
+		{
+			Node cn = nl.item(i);
+			if (cn.getNodeName().compareTo(eltName) == 0)
+				return cn;
+		}
+		throw new AmqpParseException("Node \"" + n.getNodeName() +
+				"\" does not contain child element \"" + eltName + "\".");
+	}
+		
+	// String functions
+	
+	public static String firstUpper(String str)
+	{
+		if (!Character.isLowerCase(str.charAt(0)))
+			return str;
+		StringBuffer sb = new StringBuffer(str);
+		sb.setCharAt(0, Character.toUpperCase(str.charAt(0)));
+		return sb.toString();
+	}
+	
+	public static String firstLower(String str)
+	{
+		if (!Character.isUpperCase(str.charAt(0)))
+			return str;
+		StringBuffer sb = new StringBuffer(str);
+		sb.setCharAt(0, Character.toLowerCase(str.charAt(0)));
+		return sb.toString();
+	}
+	
+	public static String createSpaces(int cnt)
+	{
+		StringBuffer sb = new StringBuffer();
+		for (int i=0; i<cnt; i++)
+			sb.append(' ');
+		return sb.toString();
+	}
+    
+    public static boolean containsOnlyDigits(String str)
+    {
+        boolean foundNonDigit = false;
+        for (int i=0; i<str.length() && !foundNonDigit; i++)
+        {
+            if (!Character.isDigit(str.charAt(i)))
+            {
+                foundNonDigit = true;
+            }
+        }
+        return !foundNonDigit;
+    }
+    
+    public static boolean containsOnlyDigitsAndDecimal(String str)
+    {
+        boolean foundNonDigit = false;
+        int decimalCntr = 0;
+        for (int i=0; i<str.length() && !foundNonDigit && decimalCntr<2; i++)
+        {
+            char ch = str.charAt(i);
+            if (!(Character.isDigit(ch) || ch == '.'))
+            {
+                foundNonDigit = true;
+            }
+            else if (ch == '.')
+                decimalCntr++;
+        }
+        return !foundNonDigit && decimalCntr<2;
+    }
+}
diff --git a/qpid/cpp/gentools/src/org/apache/qpid/gentools/VersionConsistencyCheck.java b/qpid/cpp/gentools/src/org/apache/qpid/gentools/VersionConsistencyCheck.java
new file mode 100644
index 0000000000..1f6b9f1a6d
--- /dev/null
+++ b/qpid/cpp/gentools/src/org/apache/qpid/gentools/VersionConsistencyCheck.java
@@ -0,0 +1,26 @@
+/*
+ *
+ * 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;
+
+public interface VersionConsistencyCheck
+{
+	public boolean isVersionConsistent(AmqpVersionSet globalVersionSet);
+}